1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2
 
2
 
 
 
 
2
 
2
 
2
2
2
 
 
 
 
1
 
 
 
 
 
 
2
 
 
 
2
 
 
 
2
 
2
 
 
 
 
 
 
 
1
2
 
 
 
 
 
2
 
 
2
 
 
2
2
 
1
 
 
 
2
 
 
1
1
1
 
1
1
 
 
1
1
 
1
 
 
1
 
2
 
 
 
 
 
1
 
1
 
1
 
 
 
 
1
2
2
3
3
3
3
1
 
 
3
3
 
 
 
 
3
 
 
 
1
3
1
 
 
 
1
1
 
 
 
 
 
 
 
1
 
1
1
1
 
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
1
 
 
 
 
 
 
 
 
 
 
 
1
 
 
6
6
 
1
 
2
 
1
 
2
 
 
 
 
1
1
 
1
 
 
 
 
1
 
 
 
 
 
 
1
 
 
1
1
 
 
1
1
 
1
1
1
1
1
1
1
 
1
1
 
1
 
 
 
 
/*
example.js
 
quickstart example
 
instruction
    1. save this script as example.js
    2. run the shell command:
        $ npm install npmtest-marko && PORT=8081 node example.js
    3. play with the browser-demo on http://127.0.0.1:8081
*/
 
 
 
/* istanbul instrument in package npmtest_marko */
/*jslint
    bitwise: true,
    browser: true,
    maxerr: 8,
    maxlen: 96,
    node: true,
    nomen: true,
    regexp: true,
    stupid: true
*/
(function () {
    'use strict';
    var local;
 
 
 
    // run shared js-env code - init-before
    (function () {
        // init local
        local = {};
        // init modeJs
        local.modeJs = (function () {
            try {
                return typeof navigator.userAgent === 'string' &&
                    typeof document.querySelector('body') === 'object' &&
                    typeof XMLHttpRequest.prototype.open === 'function' &&
                    'browser';
            } catch (errorCaughtBrowser) {
                return module.exports &&
                    typeof process.versions.node === 'string' &&
                    typeof require('http').createServer === 'function' &&
                    'node';
            }
        }());
        // init global
        local.global = local.modeJs === 'browser'
            ? window
            : global;
        // init utility2_rollup
        local = local.global.utility2_rollup || (local.modeJs === 'browser'
            ? local.global.utility2_npmtest_marko
            : global.utility2_moduleExports);
        // export local
        local.global.local = local;
    }());
    switch (local.modeJs) {
 
 
 
    // init-after
    // run browser js-env code - init-after
    /* istanbul ignore next */
    case 'browser':
        local.testRunBrowser = function (event) {
            Eif (!event || (event &&
                    event.currentTarget &&
                    event.currentTarget.className &&
                    event.currentTarget.className.includes &&
                    event.currentTarget.className.includes('onreset'))) {
                // reset output
                Array.from(
                    document.querySelectorAll('body > .resettable')
                ).forEach(function (element) {
                    switch (element.tagName) {
                    case 'INPUT':
                    case 'TEXTAREA':
                        element.value = '';
                        break;
                    default:
                        element.textContent = '';
                    }
                });
            }
            switch (event && event.currentTarget && event.currentTarget.id) {
            case 'testRunButton1':
                // show tests
                Eif (document.querySelector('#testReportDiv1').style.display === 'none') {
                    document.querySelector('#testReportDiv1').style.display = 'block';
                    document.querySelector('#testRunButton1').textContent =
                        'hide internal test';
                    local.modeTest = true;
                    local.testRunDefault(local);
                // hide tests
                } else {
                    document.querySelector('#testReportDiv1').style.display = 'none';
                    document.querySelector('#testRunButton1').textContent = 'run internal test';
                }
                break;
            // custom-case
            default:
                break;
            }
            Iif (document.querySelector('#inputTextareaEval1') && (!event || (event &&
                    event.currentTarget &&
                    event.currentTarget.className &&
                    event.currentTarget.className.includes &&
                    event.currentTarget.className.includes('oneval')))) {
                // try to eval input-code
                try {
                    /*jslint evil: true*/
                    eval(document.querySelector('#inputTextareaEval1').value);
                } catch (errorCaught) {
                    console.error(errorCaught);
                }
            }
        };
        // log stderr and stdout to #outputTextareaStdout1
        ['error', 'log'].forEach(function (key) {
            console[key + '_original'] = console[key];
            console[key] = function () {
                var element;
                console[key + '_original'].apply(console, arguments);
                element = document.querySelector('#outputTextareaStdout1');
                Iif (!element) {
                    return;
                }
                // append text to #outputTextareaStdout1
                element.value += Array.from(arguments).map(function (arg) {
                    return typeof arg === 'string'
                        ? arg
                        : JSON.stringify(arg, null, 4);
                }).join(' ') + '\n';
                // scroll textarea to bottom
                element.scrollTop = element.scrollHeight;
            };
        });
        // init event-handling
        ['change', 'click', 'keyup'].forEach(function (event) {
            Array.from(document.querySelectorAll('.on' + event)).forEach(function (element) {
                element.addEventListener(event, local.testRunBrowser);
            });
        });
        // run tests
        local.testRunBrowser();
        break;
 
 
 
    // run node js-env code - init-after
    /* istanbul ignore next */
    case 'node':
        // export local
        module.exports = local;
        // require modules
        local.fs = require('fs');
        local.http = require('http');
        local.url = require('url');
        // init assets
        local.assetsDict = local.assetsDict || {};
        /* jslint-ignore-begin */
        local.assetsDict['/assets.index.template.html'] = '\
<!doctype html>\n\
<html lang="en">\n\
<head>\n\
<meta charset="UTF-8">\n\
<meta name="viewport" content="width=device-width, initial-scale=1">\n\
<title>{{env.npm_package_name}} (v{{env.npm_package_version}})</title>\n\
<style>\n\
/*csslint\n\
    box-sizing: false,\n\
    universal-selector: false\n\
*/\n\
* {\n\
    box-sizing: border-box;\n\
}\n\
body {\n\
    background: #dde;\n\
    font-family: Arial, Helvetica, sans-serif;\n\
    margin: 2rem;\n\
}\n\
body > * {\n\
    margin-bottom: 1rem;\n\
}\n\
.utility2FooterDiv {\n\
    margin-top: 20px;\n\
    text-align: center;\n\
}\n\
</style>\n\
<style>\n\
/*csslint\n\
*/\n\
textarea {\n\
    font-family: monospace;\n\
    height: 10rem;\n\
    width: 100%;\n\
}\n\
textarea[readonly] {\n\
    background: #ddd;\n\
}\n\
</style>\n\
</head>\n\
<body>\n\
<!-- utility2-comment\n\
<div id="ajaxProgressDiv1" style="background: #d00; height: 2px; left: 0; margin: 0; padding: 0; position: fixed; top: 0; transition: background 0.5s, width 1.5s; width: 25%;"></div>\n\
utility2-comment -->\n\
<h1>\n\
<!-- utility2-comment\n\
    <a\n\
        {{#if env.npm_package_homepage}}\n\
        href="{{env.npm_package_homepage}}"\n\
        {{/if env.npm_package_homepage}}\n\
        target="_blank"\n\
    >\n\
utility2-comment -->\n\
        {{env.npm_package_name}} (v{{env.npm_package_version}})\n\
<!-- utility2-comment\n\
    </a>\n\
utility2-comment -->\n\
</h1>\n\
<h3>{{env.npm_package_description}}</h3>\n\
<!-- utility2-comment\n\
<h4><a download href="assets.app.js">download standalone app</a></h4>\n\
<button class="onclick onreset" id="testRunButton1">run internal test</button><br>\n\
<div id="testReportDiv1" style="display: none;"></div>\n\
utility2-comment -->\n\
\n\
\n\
\n\
<label>stderr and stdout</label>\n\
<textarea class="resettable" id="outputTextareaStdout1" readonly></textarea>\n\
<!-- utility2-comment\n\
{{#if isRollup}}\n\
<script src="assets.app.js"></script>\n\
{{#unless isRollup}}\n\
utility2-comment -->\n\
<script src="assets.utility2.rollup.js"></script>\n\
<script src="jsonp.utility2._stateInit?callback=window.utility2._stateInit"></script>\n\
<script src="assets.npmtest_marko.rollup.js"></script>\n\
<script src="assets.example.js"></script>\n\
<script src="assets.test.js"></script>\n\
<!-- utility2-comment\n\
{{/if isRollup}}\n\
utility2-comment -->\n\
<div class="utility2FooterDiv">\n\
    [ this app was created with\n\
    <a href="https://github.com/kaizhu256/node-utility2" target="_blank">utility2</a>\n\
    ]\n\
</div>\n\
</body>\n\
</html>\n\
';
        /* jslint-ignore-end */
        Iif (local.templateRender) {
            local.assetsDict['/'] = local.templateRender(
                local.assetsDict['/assets.index.template.html'],
                {
                    env: local.objectSetDefault(local.env, {
                        npm_package_description: 'the greatest app in the world!',
                        npm_package_name: 'my-app',
                        npm_package_nameAlias: 'my_app',
                        npm_package_version: '0.0.1'
                    })
                }
            );
        } else {
            local.assetsDict['/'] = local.assetsDict['/assets.index.template.html']
                .replace((/\{\{env\.(\w+?)\}\}/g), function (match0, match1) {
                    // jslint-hack
                    String(match0);
                    switch (match1) {
                    case 'npm_package_description':
                        return 'the greatest app in the world!';
                    case 'npm_package_name':
                        return 'my-app';
                    case 'npm_package_nameAlias':
                        return 'my_app';
                    case 'npm_package_version':
                        return '0.0.1';
                    }
                });
        }
        // run the cli
        Eif (local.global.utility2_rollup || module !== require.main) {
            break;
        }
        local.assetsDict['/assets.example.js'] =
            local.assetsDict['/assets.example.js'] ||
            local.fs.readFileSync(__filename, 'utf8');
        // bug-workaround - long $npm_package_buildCustomOrg
        /* jslint-ignore-begin */
        local.assetsDict['/assets.npmtest_marko.rollup.js'] =
            local.assetsDict['/assets.npmtest_marko.rollup.js'] ||
            local.fs.readFileSync(
                local.npmtest_marko.__dirname + '/lib.npmtest_marko.js',
                'utf8'
            ).replace((/^#!/), '//');
        /* jslint-ignore-end */
        local.assetsDict['/favicon.ico'] = local.assetsDict['/favicon.ico'] || '';
        // if $npm_config_timeout_exit exists,
        // then exit this process after $npm_config_timeout_exit ms
        if (Number(process.env.npm_config_timeout_exit)) {
            setTimeout(process.exit, Number(process.env.npm_config_timeout_exit));
        }
        // start server
        if (local.global.utility2_serverHttp1) {
            break;
        }
        process.env.PORT = process.env.PORT || '8081';
        console.error('server starting on port ' + process.env.PORT);
        local.http.createServer(function (request, response) {
            request.urlParsed = local.url.parse(request.url);
            if (local.assetsDict[request.urlParsed.pathname] !== undefined) {
                response.end(local.assetsDict[request.urlParsed.pathname]);
                return;
            }
            response.statusCode = 404;
            response.end();
        }).listen(process.env.PORT);
        break;
    }
}());
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
 
 
 
 
 
 
 
 
 
 
2
 
2
 
 
 
 
2
 
2
 
2
2
2
 
 
 
 
1
 
 
 
 
 
 
2
 
 
 
2
 
2
 
2
1
 
1
1
1
 
 
 
 
 
/* istanbul instrument in package npmtest_marko */
/*jslint
    bitwise: true,
    browser: true,
    maxerr: 8,
    maxlen: 96,
    node: true,
    nomen: true,
    regexp: true,
    stupid: true
*/
(function () {
    'use strict';
    var local;
 
 
 
    // run shared js-env code - init-before
    (function () {
        // init local
        local = {};
        // init modeJs
        local.modeJs = (function () {
            try {
                return typeof navigator.userAgent === 'string' &&
                    typeof document.querySelector('body') === 'object' &&
                    typeof XMLHttpRequest.prototype.open === 'function' &&
                    'browser';
            } catch (errorCaughtBrowser) {
                return module.exports &&
                    typeof process.versions.node === 'string' &&
                    typeof require('http').createServer === 'function' &&
                    'node';
            }
        }());
        // init global
        local.global = local.modeJs === 'browser'
            ? window
            : global;
        // init utility2_rollup
        local = local.global.utility2_rollup || local;
        // init lib
        local.local = local.npmtest_marko = local;
        // init exports
        if (local.modeJs === 'browser') {
            local.global.utility2_npmtest_marko = local;
        } else {
            module.exports = local;
            module.exports.__dirname = __dirname;
            module.exports.module = module;
        }
    }());
}());
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
 
 
 
 
 
 
 
 
 
 
 
2
 
2
 
 
 
 
2
 
2
 
2
2
2
 
 
 
 
1
 
 
 
 
 
 
2
 
 
2
 
 
1
 
 
 
1
 
 
1
 
1
 
 
2
 
 
 
 
 
2
2
 
2
 
 
 
 
 
1
 
 
 
 
 
1
 
 
 
 
 
2
2
 
2
 
 
 
 
 
1
 
 
 
 
 
 
1
 
 
 
1
 
 
1
 
 
 
 
 
 
1
 
 
 
 
 
 
1
1
 
 
1
 
 
 
 
 
 
1
1
1
1
1
1
 
 
1
 
 
 
 
2
2
 
 
1
 
 
 
 
 
 
2
2
 
 
1
 
 
 
 
 
 
2
2
 
 
1
 
 
 
 
 
 
2
2
 
 
1
 
 
 
 
 
 
1
1
 
 
 
1
1
 
 
 
 
/* istanbul instrument in package npmtest_marko */
/*jslint
    bitwise: true,
    browser: true,
    maxerr: 8,
    maxlen: 96,
    node: true,
    nomen: true,
    regexp: true,
    stupid: true
*/
(function () {
    'use strict';
    var local;
 
 
 
    // run shared js-env code - init-before
    (function () {
        // init local
        local = {};
        // init modeJs
        local.modeJs = (function () {
            try {
                return typeof navigator.userAgent === 'string' &&
                    typeof document.querySelector('body') === 'object' &&
                    typeof XMLHttpRequest.prototype.open === 'function' &&
                    'browser';
            } catch (errorCaughtBrowser) {
                return module.exports &&
                    typeof process.versions.node === 'string' &&
                    typeof require('http').createServer === 'function' &&
                    'node';
            }
        }());
        // init global
        local.global = local.modeJs === 'browser'
            ? window
            : global;
        switch (local.modeJs) {
        // re-init local from window.local
        case 'browser':
            local = local.global.utility2.objectSetDefault(
                local.global.utility2_rollup || local.global.local,
                local.global.utility2
            );
            break;
        // re-init local from example.js
        case 'node':
            local = (local.global.utility2_rollup || require('utility2'))
                .requireReadme();
            break;
        }
        // export local
        local.global.local = local;
    }());
 
 
 
    // run shared js-env code - function
    (function () {
        return;
    }());
    switch (local.modeJs) {
 
 
 
    // run browser js-env code - function
    case 'browser':
        break;
 
 
 
    // run node js-env code - function
    case 'node':
        break;
    }
 
 
 
    // run shared js-env code - init-after
    (function () {
        return;
    }());
    switch (local.modeJs) {
 
 
 
    // run browser js-env code - init-after
    case 'browser':
        local.testCase_browser_nullCase = local.testCase_browser_nullCase || function (
            options,
            onError
        ) {
        /*
         * this function will test browsers's null-case handling-behavior-behavior
         */
            onError(null, options);
        };
 
        // run tests
        local.nop(local.modeTest &&
            document.querySelector('#testRunButton1') &&
            document.querySelector('#testRunButton1').click());
        break;
 
 
 
    // run node js-env code - init-after
    /* istanbul ignore next */
    case 'node':
        local.testCase_buildApidoc_default = local.testCase_buildApidoc_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildApidoc's default handling-behavior-behavior
         */
            options = { modulePathList: module.paths };
            local.buildApidoc(options, onError);
        };
 
        local.testCase_buildApp_default = local.testCase_buildApp_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildApp's default handling-behavior-behavior
         */
            local.testCase_buildReadme_default(options, local.onErrorThrow);
            local.testCase_buildLib_default(options, local.onErrorThrow);
            local.testCase_buildTest_default(options, local.onErrorThrow);
            local.testCase_buildCustomOrg_default(options, local.onErrorThrow);
            options = [];
            local.buildApp(options, onError);
        };
 
        local.testCase_buildCustomOrg_default = local.testCase_buildCustomOrg_default ||
            function (options, onError) {
            /*
             * this function will test buildCustomOrg's default handling-behavior
             */
                options = {};
                local.buildCustomOrg(options, onError);
            };
 
        local.testCase_buildLib_default = local.testCase_buildLib_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildLib's default handling-behavior
         */
            options = {};
            local.buildLib(options, onError);
        };
 
        local.testCase_buildReadme_default = local.testCase_buildReadme_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildReadme's default handling-behavior-behavior
         */
            options = {};
            local.buildReadme(options, onError);
        };
 
        local.testCase_buildTest_default = local.testCase_buildTest_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildTest's default handling-behavior
         */
            options = {};
            local.buildTest(options, onError);
        };
 
        local.testCase_webpage_default = local.testCase_webpage_default || function (
            options,
            onError
        ) {
        /*
         * this function will test webpage's default handling-behavior
         */
            options = { modeCoverageMerge: true, url: local.serverLocalHost + '?modeTest=1' };
            local.browserTest(options, onError);
        };
 
        // run test-server
        local.testRunServer(local);
        break;
    }
}());
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
var marko = require('./');
 
function defineRenderer(def) {
    var template = def.template;
    var getTemplateData = def.getTemplateData;
    var renderer = def.renderer;
 
    if (typeof template === 'string') {
        template = marko.load(template);
    }
 
    var createOut;
 
    if (template) {
        createOut = template.createOut;
    } else {
        createOut = def.createOut || marko.createOut;
    }
 
    if (!renderer) {
        // Create a renderer function that takes care of translating
        // the input properties to a view state. Also, this renderer
        // takes care of re-using existing components.
        renderer = function renderer(input, out) {
            var newProps = input;
 
            if (!newProps) {
                // Make sure we always have a non-null input object
                newProps = {};
            }
 
            // Use getTemplateData(state, props, out) to get the template
            // data. If that method is not provided then just use the
            // the state (if provided) or the input data.
            var templateData = getTemplateData ?
                getTemplateData(newProps, out) :
                newProps;
 
            // Render the template associated with the component using the final template
            // data that we constructed
            template.render(templateData, out);
        };
    }
 
    renderer.render = function(input) {
        var out = createOut();
        renderer(input, out);
        return out.end();
    };
 
    return renderer;
}
 
module.exports = defineRenderer;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
2
 
2
2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
require('./runtime/env-init');
 
var assign = require('object-assign');
var express = module.parent.require('express');
patchResponse(express.response);
delete require.cache[__filename];
 
module.exports = function markoAppMiddleware() {
    var sacrificialApp = express();
 
    sacrificialApp.once('mount', function onmount(parent) {
        // Patch the response
        patchResponse(parent.response);
 
        // Remove sacrificial express app
        parent._router.stack.pop();
    });
 
    return sacrificialApp;
}
 
function patchResponse(response) {
    response.marko = response.marko || function(template, data) {
        if(typeof template === 'string') {
            throw new Error(
                'res.marko does not take a template name or path like res.render.  ' +
                'Instead you should use `require(\'./path/to/template.marko\')` ' +
                'and pass the loaded template to this function.'
            );
        }
 
        var res = this;
        var req = res.req;
        var app = res.app;
        var $global = assign({ app, req, res }, app.locals, res.locals);
 
        if (data) {
            data = assign(data, {
                $global: assign($global, data.$global)
            });
        } else {
            data = { $global };
        }
 
        res.set({ 'content-type': 'text/html; charset=utf-8' });
 
        template.render(data, res);
    };
}
 
 

1
2
1
 
module.exports = require('./runtime/html');
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
1
 
1
 
1
 
 
2
2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
var ready = require('./ready');
 
var idRegExp = /^\#(\S+)( .*)?/;
 
exports.patchComponent = function(jQuery) {
    /* globals window */
 
    Eif (!jQuery) {
        jQuery = window.$;
        if (!jQuery) {
            throw new Error('jQuery not found');
        }
    }
 
    require('./components/Component').prototype.$ = function jqueryProxy(arg) {
        var args = arguments;
        var self = this;
 
        if (args.length === 1) {
            //Handle an "ondomready" callback function
            if (typeof arg === 'function') {
                return ready(function() {
                    arg.call(self);
                });
            } else if (typeof arg === 'string') {
                var match = idRegExp.exec(arg);
                //Reset the search to 0 so the next call to exec will start from the beginning for the new string
                if (match != null) {
                    var componentElId = match[1];
                    if (match[2] == null) {
                        return jQuery(self.getEl(componentElId));
                    } else {
                        return jQuery('#' + self.getElId(componentElId) + match[2]);
                    }
                } else {
                    var rootEl = self.getEl();
                    if (!rootEl) {
                        throw new Error('Root element is not defined for component');
                    }
                    if (rootEl) {
                        return jQuery(arg, rootEl);
                    }
                }
            }
        } else if (args.length === 2 && typeof args[1] === 'string') {
            return jQuery(arg, self.getEl(args[1]));
        } else if (args.length === 0) {
            return jQuery(self.el);
        }
        return jQuery.apply(window, arguments);
    };
};
 
 
 
 

1
2
1
 
exports.install = function() {};
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
 
1
 
1
1
1
1
1
 
1
1
 
 
1
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
1
1
 
1
 
 
 
1
 
1
 
 
1
 
 
1
 
1
 
 
 
1
 
 
 
1
1
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
1
1
1
1
 
 
 
1
 
1
 
1
 
 
 
 
'use strict';
require('./runtime/env-init');
 
const path = require('path');
const resolveFrom = require('resolve-from');
const fs = require('fs');
const fsReadOptions = { encoding: 'utf8' };
const MARKO_EXTENSIONS = Symbol('MARKO_EXTENSIONS');
 
function normalizeExtension(extension) {
    Iif (extension.charAt(0) !== '.') {
        extension = '.' + extension;
    }
    return extension;
}
 
function compile(templatePath, markoCompiler, compilerOptions) {
    if (compilerOptions) {
        compilerOptions = Object.assign({}, markoCompiler.defaultOptions, compilerOptions);
    } else {
        compilerOptions = markoCompiler.defaultOptions;
    }
 
    var writeToDisk = compilerOptions.writeToDisk;
 
    var templateSrc;
    var compiledSrc;
 
    if (writeToDisk === false) {
        // Don't write the compiled template to disk. Instead, load it
        // directly from the compiled source using the internals of the
        // Node.js module loading system.
        templateSrc = fs.readFileSync(templatePath, fsReadOptions);
        compiledSrc = markoCompiler.compile(templateSrc, templatePath);
    } else {
        var targetFile = templatePath + '.js';
 
        if (markoCompiler.defaultOptions.assumeUpToDate && fs.existsSync(targetFile)) {
            // If the target file already exists and "assumeUpToDate" then just use the previously
            // compiled template.
            return fs.readFileSync(targetFile, fsReadOptions);
        }
 
        var targetDir = path.dirname(templatePath);
 
        var isUpToDate = markoCompiler.checkUpToDate(targetFile);
 
        if (isUpToDate) {
            compiledSrc = fs.readFileSync(targetFile, fsReadOptions);
        } else {
            templateSrc = fs.readFileSync(templatePath, fsReadOptions);
        	compiledSrc = markoCompiler.compile(templateSrc, templatePath, compilerOptions);
 
            // Write to a temporary file and move it into place to avoid problems
            // assocatiated with multiple processes write to the same file. We only
            // write the compiled source code to disk so that stack traces will
            // be accurate.
            var filename = path.basename(targetFile);
            var tempFile = path.join(targetDir, '.' + process.pid + '.' + Date.now() + '.' + filename);
            fs.writeFileSync(tempFile, compiledSrc, fsReadOptions);
            fs.renameSync(tempFile, targetFile);
        }
    }
 
    // We attach a path to the compiled template so that hot reloading will work.
    return compiledSrc;
}
 
function getLoadedTemplate(path) {
    var cached = require.cache[path];
    return cached && cached.exports.render ? cached.exports : undefined;
}
 
function install(options) {
    options = options || {};
 
    var requireExtensions = options.require ? // options.require introduced for testing
        options.require.extensions :
        require.extensions;
 
    var compilerOptions = options.compilerOptions;
 
    Iif (compilerOptions) {
        require('./compiler').configure(compilerOptions);
    } else {
        compilerOptions = {};
    }
 
    var extensions = [];
 
    Iif (options.extension) {
        extensions.push(options.extension);
    }
 
    Iif (options.extensions) {
        extensions = extensions.concat(options.extensions);
    }
 
    Eif (extensions.length === 0) {
        extensions.push('.marko');
    }
 
    function markoRequireExtension(module, filename) {
        var targetFile = filename + '.js';
        var cachedTemplate = getLoadedTemplate(targetFile) || getLoadedTemplate(filename);
        if (cachedTemplate) {
            // The template has already been loaded so use the exports of the already loaded template
            module.exports = cachedTemplate;
            return;
        }
 
        // Resolve the appropriate compiler relative to the location of the
        // marko template file on disk using the "resolve-from" module.
        var dirname = path.dirname(filename);
        var markoCompilerModulePath = resolveFrom(dirname, 'marko/compiler');
        var markoCompiler = require(markoCompilerModulePath);
 
        // Now use the appropriate Marko compiler to compile the Marko template
        // file to JavaScript source code:
        var compiledSrc = compile(filename, markoCompiler, compilerOptions);
 
        // Append ".js" to the filename since that is where we write the compiled
        // source code that is being loaded. This allows stack traces to match up.
        module._compile(compiledSrc, targetFile);
    }
 
    requireExtensions[MARKO_EXTENSIONS] = requireExtensions[MARKO_EXTENSIONS] ||
        (requireExtensions[MARKO_EXTENSIONS] = []);
 
    extensions.forEach((extension) => {
        extension = normalizeExtension(extension);
        requireExtensions[extension] = markoRequireExtension;
        requireExtensions[MARKO_EXTENSIONS].push(extension);
    });
}
 
install();
 
exports.install = install;
 
exports.getExtensions = function() {
    return require.extensions[MARKO_EXTENSIONS];
};
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
1
 
1
1
 
1
 
1
 
 
 
 
 
 
 
1
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
1
 
1
 
 
 
 
 
 
 
 
/*
    jQuery's doc.ready/$(function(){}) should
    you wish to use a cross-browser domReady solution
    without opting for a library.
 
    Demo: http://jsfiddle.net/zKLpb/
 
    usage:
    $(function(){
        // your code
    });
 
    Parts: jQuery project, Diego Perini, Lucent M.
    Previous version from Addy Osmani (https://raw.github.com/addyosmani/jquery.parts/master/jquery.documentReady.js)
 
    This version: Patrick Steele-Idem
    - Converted to CommonJS module
    - Code cleanup
    - Fixes for IE <=10
*/
 
/* globals window */
 
var isReady = false;
var readyBound = false;
 
var defaultWindow = typeof window != 'undefined' && window;
var defaultDocument = typeof document != 'undefined' && document;
 
var listeners = [];
 
function domReadyCallback() {
    for (var i = 0, len = listeners.length; i < len; i++) {
        var listener = listeners[i];
        listener[0].call(listener[1]);
    }
    listeners = null;
}
 
function bindReady(doc) {
    var toplevel = false;
    var win = doc.defaultView || defaultWindow || doc;
 
    // Handle when the DOM is ready
    function domReady() {
        // Make sure that the DOM is not already loaded
        if (!isReady) {
            // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
            if (!doc.body) {
                return setTimeout(domReady, 1);
            }
            // Remember that the DOM is ready
            isReady = true;
            // If there are functions bound, to execute
            domReadyCallback();
            // Execute all of them
        }
    } // /ready()
 
    // The ready event handler
    function domContentLoaded() {
        if (doc.addEventListener) {
            doc.removeEventListener("DOMContentLoaded", domContentLoaded, false);
            doc.removeEventListener("load", domContentLoaded, false);
        } else {
            // we're here because readyState !== "loading" in oldIE
            // which is good enough for us to call the dom ready!
            doc.detachEvent("onreadystatechange", domContentLoaded);
            doc.detachEvent("onload", domContentLoaded);
        }
        domReady();
    }
 
    // The DOM ready check for Internet Explorer
    function doScrollCheck() {
        if (isReady) {
            return;
        }
 
        try {
            // If IE is used, use the trick by Diego Perini
            // http://javascript.nwbox.com/IEContentLoaded/
            doc.documentElement.doScroll("left");
        } catch (error) {
            setTimeout(doScrollCheck, 1);
            return;
        }
        // and execute any waiting functions
        domReady();
    }
 
    // Catch cases where $ is called after the
    // browser event has already occurred. IE <= 10 has a bug that results in 'interactive' being assigned
    // to the readyState before the DOM is really ready
    if (document.attachEvent ? document.readyState === "complete" : document.readyState !== "loading") {
        // We will get here if the browser is IE and the readyState === 'complete' or the browser
        // is not IE and the readyState === 'interactive' || 'complete'
        domReady(doc);
    } else if (doc.addEventListener) { // Standards-based browsers support DOMContentLoaded
        // Use the handy event callback
        doc.addEventListener("DOMContentLoaded", domContentLoaded, false);
        // A fallback to win.onload, that will always work
        win.addEventListener("load", domContentLoaded, false);
        // If IE event model is used
    } else if (doc.attachEvent) {
        // ensure firing before onload,
        // maybe late but safe also for iframes
        doc.attachEvent("onreadystatechange", domContentLoaded);
        // A fallback to win.onload, that will always work
        win.attachEvent("onload", domContentLoaded);
        // If IE and not a frame
        // continually check to see if the document is ready
        try {
            toplevel = win.frameElement == null;
        } catch (e) {}
        if (doc.documentElement.doScroll && toplevel) {
            doScrollCheck();
        }
    }
}
 
function ready(callback, thisObj, doc) {
    if (isReady) {
        return callback.call(thisObj);
    }
 
    listeners.push([callback, thisObj]);
 
    if (!readyBound) {
        readyBound = true;
        bindReady(doc || defaultDocument);
    }
}
 
module.exports = ready;
 
module.exports.patchComponent = function() {
    require('./components/Component').prototype.ready = function (callback) {
        var document = this.el.ownerDocument;
        ready(callback, this, document);
    };
};
 
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 
 
 
 
 
 
 
 
 
 
1
 
/*
This module is used to monkey patch `Template.prototype` to add a new `stream(templateData)` method. Since
streaming module is likely not needed in the browser, we have made this method optional.
 
Template.prototype.stream is always available on the server, but if you need streaming in the browser you must add
the following line to your app:
 
    require('marko/stream');
 
*/
 
require('./runtime/stream');
 

1
2
1
 
module.exports = require('./runtime/vdom');
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
1
1
1
1
 
 
1
1
 
1
1
1
1
 
 
1
1
 
 
1
 
1
1
 
 
 
 
1
 
1
 
1
1
 
1
 
1
 
 
 
 
 
1
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
1
 
 
 
 
 
 
 
1
1
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
1
 
 
 
1
 
 
 
 
 
1
1
 
 
 
1
1
 
 
 
 
 
1
 
1
1
 
 
1
2
2
 
 
1
 
2
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
1
1
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
var fs = require('fs');
var nodePath = require('path');
var cwd = process.cwd();
var resolveFrom = require('resolve-from');
 
// Try to use the Marko compiler installed with the project
var markoCompilerPath;
const markocPkgVersion = require('../package.json').version;
 
var markoPkgVersion;
try {
    var markoPkgPath = resolveFrom(process.cwd(), 'marko/package.json');
    markoPkgVersion = require(markoPkgPath).version;
} catch(e) {}
 
try {
    markoCompilerPath = resolveFrom(process.cwd(), 'marko/compiler');
} catch(e) {}
 
var markoCompiler;
 
Eif (markoCompilerPath) {
    markoCompiler = require(markoCompilerPath);
} else {
    markoCompiler = require('../compiler');
}
 
var Minimatch = require('minimatch').Minimatch;
 
var appModulePath = require('app-module-path');
 
require('raptor-polyfill/string/startsWith');
require('raptor-polyfill/string/endsWith');
 
markoCompiler.defaultOptions.checkUpToDate = false;
 
var mmOptions = {
    matchBase: true,
    dot: true,
    flipNegate: true
};
 
function relPath(path) {
    if (path.startsWith(cwd)) {
        return path.substring(cwd.length+1);
    }
}
 
var args = require('argly').createParser({
        '--help': {
            type: 'boolean',
            description: 'Show this help message'
        },
        '--files --file -f *': {
            type: 'string[]',
            description: 'A set of directories or files to compile'
        },
        '--ignore -i': {
            type: 'string[]',
            description: 'An ignore rule (default: --ignore "/node_modules" ".*")'
        },
        '--clean -c': {
            type: 'boolean',
            description: 'Clean all of the *.marko.js files'
        },
        '--force': {
            type: 'boolean',
            description: 'Force template recompilation even if unchanged'
        },
        '--paths -p': {
            type: 'string[]',
            description: 'Additional directories to add to the Node.js module search path'
        },
        '--vdom -V': {
            type: 'boolean',
            description: 'VDOM output'
        },
        '--version -v': {
            type: 'boolean',
            description: 'Print markoc and marko compiler versions to the console'
        }
    })
    .usage('Usage: $0 <pattern> [options]')
    .example('Compile a single template', '$0 template.marko')
    .example('Compile all templates in the current directory', '$0 .')
    .example('Compile multiple templates', '$0 template.marko src/ foo/')
    .example('Delete all *.marko.js files in the current directory', '$0 . --clean')
    .validate(function(result) {
        Iif (result.help) {
            this.printUsage();
            process.exit(0);
        } else Iif (result.version) {
            console.log('markoc@' + markocPkgVersion);
 
            if (markoPkgVersion) {
                console.log('marko@' + markoPkgVersion);
            }
 
            process.exit(0);
        } else Eif (!result.files || result.files.length === 0) {
            this.printUsage();
            process.exit(1);
        }
    })
    .onError(function(err) {
        this.printUsage();
 
        if (err) {
            console.log();
            console.log(err);
        }
 
        process.exit(1);
    })
    .parse();
 
var output = 'html';
 
Iif (args.vdom) {
    output = 'vdom';
}
 
var compileOptions = {
    output: output,
    compilerType: 'markoc',
    compilerVersion: markoPkgVersion || markocPkgVersion
};
 
var force = args.force;
Iif (force) {
    markoCompiler.defaultOptions.checkUpToDate = false;
}
 
var paths = args.paths;
Iif (paths && paths.length) {
    paths.forEach(function(path) {
        appModulePath.addPath(nodePath.resolve(cwd, path));
    });
}
 
var ignoreRules = args.ignore;
 
Eif (!ignoreRules) {
    ignoreRules = ['/node_modules', '.*'];
}
 
ignoreRules = ignoreRules.filter(function (s) {
    s = s.trim();
    return s && !s.match(/^#/);
});
 
ignoreRules = ignoreRules.map(function (pattern) {
 
    return new Minimatch(pattern, mmOptions);
});
 
 
function isIgnored(path, dir, stat) {
    if (path.startsWith(dir)) {
        path = path.substring(dir.length);
    }
 
    path = path.replace(/\\/g, '/');
 
    var ignore = false;
    var ignoreRulesLength = ignoreRules.length;
    for (var i=0; i<ignoreRulesLength; i++) {
        var rule = ignoreRules[i];
 
        var match = rule.match(path);
 
        if (!match && stat && stat.isDirectory()) {
            try {
                stat = fs.statSync(path);
            } catch(e) {}
 
            if (stat && stat.isDirectory()) {
                match = rule.match(path + '/');
            }
        }
 
 
        if (match) {
            if (rule.negate) {
                ignore = false;
            } else {
                ignore = true;
            }
        }
    }
 
    return ignore;
}
 
function walk(files, options, done) {
    if (!files || files.length === 0) {
        done('No files provided');
    }
 
    var pending = 0;
 
    if (!Array.isArray(files)) {
        files = [files];
    }
 
    var fileCallback = options.file;
    var context = {
        errors: [],
        beginAsync: function() {
            pending++;
        },
        endAsync: function(err) {
            if (err) {
                this.errors.push(err);
            }
 
            pending--;
 
            if (pending === 0) {
                if (this.errors.length) {
                    done(this.errors);
                } else {
                    done(null);
                }
 
            }
        }
    };
 
    function doWalk(dir) {
        context.beginAsync();
        fs.readdir(dir, function(err, list) {
            if (err) {
                return context.endAsync(err);
            }
 
            if (list.length) {
                list.forEach(function(basename) {
                    var file = nodePath.join(dir, basename);
 
                    context.beginAsync();
                    fs.stat(file, function(err, stat) {
                        if (err) {
                            return context.endAsync(err);
                        }
 
                        if (!isIgnored(file, dir, stat)) {
                            if (stat && stat.isDirectory()) {
                                doWalk(file);
                            } else {
                                fileCallback(file, context);
                            }
                        }
 
                        context.endAsync();
                    });
                });
            }
 
            context.endAsync();
        });
    }
 
    for (var i=0; i<files.length; i++) {
        var file = nodePath.resolve(cwd, files[i]);
 
        var stat = fs.statSync(file);
 
        if (stat.isDirectory()) {
            doWalk(file);
        } else {
            fileCallback(file, context);
        }
    }
}
 
Iif (args.clean) {
    var deleteCount = 0;
 
    walk(
        args.files,
        {
            file: function(file, context) {
                var basename = nodePath.basename(file);
 
                if (basename.endsWith('.marko.js') || basename.endsWith('.marko.html') || basename.endsWith('.marko.xml.js')) {
                    context.beginAsync();
                    fs.unlink(file, function(err) {
                        if (err) {
                            return context.endAsync(err);
                        }
                        deleteCount++;
                        console.log('Deleted: ' + file);
                        context.endAsync();
                    });
 
 
                }
            }
        },
        function(err) {
            if (deleteCount === 0) {
                console.log('No *.marko.js files were found. Already clean.');
            } else {
                console.log('Deleted ' + deleteCount + ' file(s)');
            }
 
        });
 
} else {
    var found = {};
    var compileCount = 0;
    var failed;
    var failed = [];
 
    var compile = function(path, context) {
        if (found[path]) {
            return;
        }
 
        found[path] = true;
 
        var outPath = path + '.js';
        console.log('Compiling:\n  Input:  ' + relPath(path) + '\n  Output: ' + relPath(outPath) + '\n');
        context.beginAsync();
        markoCompiler.compileFile(path, compileOptions, function(err, src) {
            if (err) {
                failed.push('Failed to compile "' + relPath(path) + '". Error: ' + (err.stack || err));
                context.endAsync(err);
                return;
            }
 
            context.beginAsync();
            fs.writeFile(outPath, src, {encoding: 'utf8'}, function(err, src) {
                if (err) {
                    failed.push('Failed to write "' + path + '". Error: ' + (err.stack || err));
                    context.endAsync(err);
                    return;
                }
 
                compileCount++;
                context.endAsync();
 
            });
 
            context.endAsync();
        });
    };
 
 
    Iif (args.files && args.files.length) {
        walk(
            args.files,
            {
                file: function(file, context) {
                    var basename = nodePath.basename(file);
 
                    if (basename.endsWith('.marko') || basename.endsWith('.marko.html') || basename.endsWith('.marko.xml')) {
                        compile(file, context);
                    }
                }
            },
            function(err) {
                if (err) {
                    if (failed.length) {
                        console.error('The following errors occurred:\n- ' + failed.join('\n- '));
                    } else {
                        console.error(err);
                    }
 
                    return;
                }
 
                if (compileCount === 0) {
                    console.log('No templates found');
                } else {
                    console.log('Compiled ' + compileCount + ' templates(s)');
                }
 
            });
    }
}
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
1
1
 
1
1
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
var enabled = false;
var browserRefreshClient = require('browser-refresh-client');
 
exports.enable = function() {
    Eif (!browserRefreshClient.isBrowserRefreshEnabled()) {
        return;
    }
 
    if (enabled) {
        return;
    }
 
    enabled = true;
 
    // We set an environment variable so that _all_ marko modules
    // installed in the project will have browser refresh enabled.
    process.env.MARKO_BROWSER_REFRESH = 'true';
 
    var hotReload = require('../hot-reload');
    hotReload.enable();
 
    browserRefreshClient
        .enableSpecialReload('*.marko marko.json marko-tag.json')
        .onFileModified(function(path) {
            hotReload.handleFileModified(path);
        });
};
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
 
1
1
 
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
 
1
1
1
1
1
 
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
1
1
1
1
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
1
 
1
 
 
'use strict';
var isArray = Array.isArray;
var ok = require('assert').ok;
 
var Node = require('./ast/Node');
var Program = require('./ast/Program');
var TemplateRoot = require('./ast/TemplateRoot');
var FunctionDeclaration = require('./ast/FunctionDeclaration');
var FunctionCall = require('./ast/FunctionCall');
var Literal = require('./ast/Literal');
var Identifier = require('./ast/Identifier');
var Comment = require('./ast/Comment');
var If = require('./ast/If');
var ElseIf = require('./ast/ElseIf');
var Else = require('./ast/Else');
var Assignment = require('./ast/Assignment');
var BinaryExpression = require('./ast/BinaryExpression');
var LogicalExpression = require('./ast/LogicalExpression');
var Vars = require('./ast/Vars');
var Return = require('./ast/Return');
var HtmlElement = require('./ast/HtmlElement');
var Html = require('./ast/Html');
var Text = require('./ast/Text');
var ForEach = require('./ast/ForEach');
var ForEachProp = require('./ast/ForEachProp');
var ForRange = require('./ast/ForRange');
var HtmlComment = require('./ast/HtmlComment');
var SelfInvokingFunction = require('./ast/SelfInvokingFunction');
var ForStatement = require('./ast/ForStatement');
var BinaryExpression = require('./ast/BinaryExpression');
var UpdateExpression = require('./ast/UpdateExpression');
var UnaryExpression = require('./ast/UnaryExpression');
var MemberExpression = require('./ast/MemberExpression');
var Code = require('./ast/Code');
var InvokeMacro = require('./ast/InvokeMacro');
var Macro = require('./ast/Macro');
var ConditionalExpression = require('./ast/ConditionalExpression');
var NewExpression = require('./ast/NewExpression');
var ObjectExpression = require('./ast/ObjectExpression');
var ArrayExpression = require('./ast/ArrayExpression');
var Property = require('./ast/Property');
var VariableDeclarator = require('./ast/VariableDeclarator');
var ThisExpression = require('./ast/ThisExpression');
var Expression = require('./ast/Expression');
var Scriptlet = require('./ast/Scriptlet');
var ContainerNode = require('./ast/ContainerNode');
var WhileStatement = require('./ast/WhileStatement');
var DocumentType = require('./ast/DocumentType');
var Declaration = require('./ast/Declaration');
var SequenceExpression = require('./ast/SequenceExpression');
var CustomTag = require('./ast/CustomTag');
 
var parseExpression = require('./util/parseExpression');
var parseStatement = require('./util/parseStatement');
var parseJavaScriptArgs = require('./util/parseJavaScriptArgs');
var replacePlaceholderEscapeFuncs = require('./util/replacePlaceholderEscapeFuncs');
var isValidJavaScriptIdentifier = require('./util/isValidJavaScriptIdentifier');
 
var DEFAULT_BUILDER;
 
function makeNode(arg) {
    if (typeof arg === 'string') {
        return parseExpression(arg, DEFAULT_BUILDER);
    } else if (arg instanceof Node) {
        return arg;
    } else if (arg == null) {
        return undefined;
    } else if (Array.isArray(arg)) {
        return arg.map((arg) => {
            return makeNode(arg);
        });
    } else {
        throw new Error('Argument should be a string or Node or null. Actual: ' + arg);
    }
}
 
var literalNull = new Literal({value: null});
var literalUndefined = new Literal({value: undefined});
var literalTrue = new Literal({value: true});
var literalFalse = new Literal({value: false});
var identifierOut = new Identifier({name: 'out'});
var identifierRequire = new Identifier({name: 'require'});
 
class Builder {
    arrayExpression(elements) {
        if (elements) {
            if (!isArray(elements)) {
                elements = [elements];
            }
 
            for (var i=0; i<elements.length; i++) {
                elements[i] = makeNode(elements[i]);
            }
        } else {
            elements = [];
        }
 
        return new ArrayExpression({elements});
    }
 
    assignment(left, right, operator) {
        if (operator == null) {
            operator = '=';
        }
        left = makeNode(left);
        right = makeNode(right);
        return new Assignment({left, right, operator});
    }
 
    binaryExpression(left, operator, right) {
        left = makeNode(left);
        right = makeNode(right);
        return new BinaryExpression({left, operator, right});
    }
 
    sequenceExpression(expressions) {
        expressions = makeNode(expressions);
        return new SequenceExpression({expressions});
    }
 
    code(value) {
        return new Code({value});
    }
 
    computedMemberExpression(object, property) {
        object = makeNode(object);
        property = makeNode(property);
        let computed = true;
 
        return new MemberExpression({object, property, computed});
    }
 
    concat(args) {
        var prev;
        let operator = '+';
 
        for (var i=1; i<arguments.length; i++) {
            var left;
            var right = makeNode(arguments[i]);
            if (i === 1) {
                left = makeNode(arguments[i-1]);
            } else {
                left = prev;
            }
 
            prev = new BinaryExpression({left, operator, right});
        }
 
        return prev;
    }
 
    conditionalExpression(test, consequent, alternate) {
        return new ConditionalExpression({test, consequent, alternate});
    }
 
    containerNode(type, generateCode) {
        if (typeof type === 'function') {
            generateCode = arguments[0];
            type = 'ContainerNode';
        }
 
        var node = new ContainerNode(type);
        if (generateCode) {
            node.setCodeGenerator(generateCode);
        }
        return node;
    }
 
    customTag(el, tagDef) {
        return new CustomTag(el, tagDef);
    }
 
    declaration(declaration) {
        return new Declaration({declaration});
    }
 
    documentType(documentType) {
        return new DocumentType({documentType});
    }
 
    elseStatement(body) {
        return new Else({body});
    }
 
    elseIfStatement(test, body, elseStatement) {
        test = makeNode(test);
 
        return new ElseIf({test, body, else: elseStatement});
    }
 
    expression(value) {
        return new Expression({value});
    }
 
    forEach(varName, inExpression, body) {
        if (arguments.length === 1) {
            var def = arguments[0];
            return new ForEach(def);
        } else {
            varName = makeNode(varName);
            inExpression = makeNode(inExpression);
            return new ForEach({varName, in: inExpression, body});
        }
    }
 
    forEachProp(nameVarName, valueVarName, inExpression, body) {
        if (arguments.length === 1) {
            var def = arguments[0];
            return new ForEachProp(def);
        } else {
            nameVarName = makeNode(nameVarName);
            valueVarName = makeNode(valueVarName);
            inExpression = makeNode(inExpression);
            return new ForEachProp({nameVarName, valueVarName, in: inExpression, body});
        }
    }
 
    forRange(varName, from, to, step, body) {
        if (arguments.length === 1) {
            var def = arguments[0];
            return new ForRange(def);
        } else {
            varName = makeNode(varName);
            from = makeNode(from);
            to = makeNode(to);
            step = makeNode(step);
            body = makeNode(body);
 
            return new ForRange({varName, from, to, step, body});
        }
    }
 
    forStatement(init, test, update, body) {
        if (arguments.length === 1) {
            var def = arguments[0];
            return new ForStatement(def);
        } else {
            init = makeNode(init);
            test = makeNode(test);
            update = makeNode(update);
            return new ForStatement({init, test, update, body});
        }
    }
 
    functionCall(callee, args) {
        callee = makeNode(callee);
 
        if (args) {
            if (!isArray(args)) {
                throw new Error('"args" should be an array');
            }
 
            for (var i=0; i<args.length; i++) {
                args[i] = makeNode(args[i]);
            }
        } else {
            args = [];
        }
 
        return new FunctionCall({callee, args});
    }
 
    functionDeclaration(name, params, body) {
        return new FunctionDeclaration({name, params, body});
    }
 
    html(argument) {
        argument = makeNode(argument);
 
        return new Html({argument});
    }
 
    htmlComment(comment) {
        return new HtmlComment({comment});
    }
 
    comment(comment) {
        return new Comment({comment});
    }
 
    htmlElement(tagName, attributes, body, argument, openTagOnly, selfClosed) {
        if (typeof tagName === 'object' && !(tagName instanceof Node)) {
            let def = arguments[0];
            return new HtmlElement(def);
        } else {
            return new HtmlElement({tagName, attributes, body, argument, openTagOnly, selfClosed});
        }
    }
 
    htmlLiteral(htmlCode) {
        var argument = new Literal({value: htmlCode});
        return new Html({argument});
    }
 
    identifier(name) {
        ok(typeof name === 'string', '"name" should be a string');
 
        if (!isValidJavaScriptIdentifier(name)) {
            var error = new Error('Invalid JavaScript identifier: ' + name);
            error.code = 'INVALID_IDENTIFIER';
            throw error;
        }
        return new Identifier({name});
    }
 
    identifierOut(name) {
        return identifierOut;
    }
 
    ifStatement(test, body, elseStatement) {
        test = makeNode(test);
 
        return new If({test, body, else: elseStatement});
    }
 
    invokeMacro(name, args, body) {
        return new InvokeMacro({name, args, body});
    }
 
    invokeMacroFromEl(el) {
        return new InvokeMacro({el});
    }
 
    literal(value) {
        return new Literal({value});
    }
 
    literalFalse() {
        return literalFalse;
    }
 
    literalNull() {
        return literalNull;
    }
 
    literalTrue() {
        return literalTrue;
    }
 
    literalUndefined() {
        return literalUndefined;
    }
 
    logicalExpression(left, operator, right) {
        left = makeNode(left);
        right = makeNode(right);
        return new LogicalExpression({left, operator, right});
    }
 
    macro(name, params, body) {
        return new Macro({name, params, body});
    }
 
    memberExpression(object, property, computed) {
        object = makeNode(object);
        property = makeNode(property);
 
        return new MemberExpression({object, property, computed});
    }
 
    moduleExports(value) {
        let object = new Identifier({name: 'module'});
        let property = new Identifier({name: 'exports'});
 
        var moduleExports = new MemberExpression({object, property });
 
        if (value) {
            return new Assignment({left: moduleExports, right: value, operator: '='});
        } else {
            return moduleExports;
        }
    }
 
    negate(argument) {
        argument = makeNode(argument);
 
        var operator = '!';
        var prefix = true;
        return new UnaryExpression({argument, operator, prefix});
    }
 
    newExpression(callee, args) {
        callee = makeNode(callee);
 
        if (args) {
            if (!isArray(args)) {
                args = [args];
            }
 
            for (var i=0; i<args.length; i++) {
                args[i] = makeNode(args[i]);
            }
        } else {
            args = [];
        }
 
        return new NewExpression({callee, args});
    }
 
    node(type, generateCode) {
        if (typeof type === 'function') {
            generateCode = arguments[0];
            type = 'Node';
        }
 
        var node = new Node(type);
        if (generateCode) {
            node.setCodeGenerator(generateCode);
        }
        return node;
    }
 
    objectExpression(properties) {
        if (properties) {
            if (!isArray(properties)) {
                properties = [properties];
            }
 
            for (var i=0; i<properties.length; i++) {
                let prop = properties[i];
                prop.value = makeNode(prop.value);
            }
        } else {
            properties = [];
        }
 
        return new ObjectExpression({properties});
    }
 
    parseExpression(str, options) {
        ok(typeof str === 'string', '"str" should be a string expression');
        var parsed = parseExpression(str, DEFAULT_BUILDER);
        return parsed;
    }
 
    parseJavaScriptArgs(args) {
        ok(typeof args === 'string', '"args" should be a string');
        return parseJavaScriptArgs(args, DEFAULT_BUILDER);
    }
 
    parseStatement(str, options) {
        ok(typeof str === 'string', '"str" should be a string expression');
        var parsed = parseStatement(str, DEFAULT_BUILDER);
        return parsed;
    }
 
    replacePlaceholderEscapeFuncs(node, context) {
        return replacePlaceholderEscapeFuncs(node, context);
    }
 
    program(body) {
        return new Program({body});
    }
 
    property(key, value) {
        key = makeNode(key);
        value = makeNode(value);
 
        return new Property({key, value});
    }
 
    renderBodyFunction(body, params) {
        let name = 'renderBody';
        if (!params) {
            params = [new Identifier({name: 'out'})];
        }
        return new FunctionDeclaration({name, params, body});
    }
 
    require(path) {
        path = makeNode(path);
 
        let callee = identifierRequire;
        let args = [ path ];
        return new FunctionCall({callee, args});
    }
 
    requireResolve(path) {
        path = makeNode(path);
 
        let callee = new MemberExpression({
            object: new Identifier({name: 'require'}),
            property: new Identifier({name: 'resolve'})
        });
 
        let args = [ path ];
        return new FunctionCall({callee, args});
    }
 
    returnStatement(argument) {
        argument = makeNode(argument);
 
        return new Return({argument});
    }
 
    scriptlet(scriptlet) {
        return new Scriptlet({
            code: scriptlet.value,
            tag: scriptlet.tag,
            block: scriptlet.block
        });
    }
 
    selfInvokingFunction(params, args, body) {
        if (arguments.length === 1) {
            body = arguments[0];
            params = null;
            args = null;
        }
 
        return new SelfInvokingFunction({params, args, body});
    }
 
    strictEquality(left, right) {
        left = makeNode(left);
        right = makeNode(right);
 
        var operator = '===';
        return new BinaryExpression({left, right, operator});
    }
 
    templateRoot(body) {
        return new TemplateRoot({body});
    }
 
    text(argument, escape, preserveWhitespace) {
        if (typeof argument === 'object' && !(argument instanceof Node)) {
            var def = arguments[0];
            return new Text(def);
        }
        argument = makeNode(argument);
 
        return new Text({argument, escape, preserveWhitespace});
    }
 
    thisExpression() {
        return new ThisExpression();
    }
 
    unaryExpression(argument, operator, prefix) {
        argument = makeNode(argument);
 
        return new UnaryExpression({argument, operator, prefix});
    }
 
    updateExpression(argument, operator, prefix) {
        argument = makeNode(argument);
        return new UpdateExpression({argument, operator, prefix});
    }
 
    variableDeclarator(id, init) {
        if (typeof id === 'string') {
            id = new Identifier({name: id});
        }
        if (init) {
            init = makeNode(init);
        }
 
        return new VariableDeclarator({id, init});
    }
 
    var(id, init, kind) {
        if (!kind) {
            kind = 'var';
        }
 
        id = makeNode(id);
        init = makeNode(init);
 
        var declarations = [
            new VariableDeclarator({id, init})
        ];
 
        return new Vars({declarations, kind});
    }
 
    vars(declarations, kind) {
        if (declarations) {
            if (Array.isArray(declarations)) {
                for (let i=0; i<declarations.length; i++) {
                    var declaration = declarations[i];
                    if (!declaration) {
                        throw new Error('Invalid variable declaration');
                    }
                    if (typeof declaration === 'string') {
                        declarations[i] = new VariableDeclarator({
                            id: new Identifier({name: declaration})
                        });
                    } else if (declaration instanceof Identifier) {
                        declarations[i] = new VariableDeclarator({
                            id: declaration
                        });
                    } else if (typeof declaration === 'object') {
                        if (!(declaration instanceof VariableDeclarator)) {
                            let id = declaration.id;
                            let init = declaration.init;
 
                            if (typeof id === 'string') {
                                id = new Identifier({name: id});
                            }
 
                            if (!id) {
                                throw new Error('Invalid variable declaration');
                            }
 
                            if (init) {
                                init = makeNode(init);
                            }
 
 
                            declarations[i] = new VariableDeclarator({id, init});
                        }
                    }
                }
            } else if (typeof declarations === 'object') {
                // Convert the object into an array of variables
                declarations = Object.keys(declarations).map((key) => {
                    let id = new Identifier({name: key});
                    let init = makeNode(declarations[key]);
                    return new VariableDeclarator({ id, init });
                });
            }
        }
 
 
        return new Vars({declarations, kind});
    }
 
    whileStatement(test, body) {
        return new WhileStatement({test, body});
    }
}
 
DEFAULT_BUILDER = new Builder();
 
Builder.DEFAULT_BUILDER = DEFAULT_BUILDER;
 
module.exports = Builder;
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
 
 
1
1
1
1
1
1
1
1
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
const isArray = Array.isArray;
const Node = require('./ast/Node');
const Literal = require('./ast/Literal');
const Identifier = require('./ast/Identifier');
const HtmlElement = require('./ast/HtmlElement');
const Html = require('./ast/Html');
const ok = require('assert').ok;
const Container = require('./ast/Container');
const createError = require('raptor-util/createError');
 
class GeneratorEvent {
    constructor(node, codegen) {
        this.node = node;
        this.codegen = codegen;
 
        this.isBefore = true;
        this.builder = codegen.builder;
        this.context = codegen.context;
 
        this.insertedNodes = null;
    }
 
    insertCode(newCode) {
        if (!this.insertedNodes) {
            this.insertedNodes = [];
        }
        this.insertedNodes = this.insertedNodes.concat(newCode);
    }
}
 
class FinalNodes {
    constructor() {
        this.nodes = [];
        this.nodes._finalNode = true; // Mark the array as a collection of final nodes
        this.lastNode = null;
    }
 
    push(node) {
        if (!node) {
            return;
        }
 
        if (node instanceof Html) {
            if (this.lastNode instanceof Html) {
                this.lastNode.append(node);
                return;
            }
        }
 
        if (node.setFinalNode) {
            node.setFinalNode(true);
        }
 
        this.lastNode = node;
        this.nodes.push(node);
    }
}
 
class CodeGenerator {
    constructor(context, options) {
        options = options || {};
        this.root = null;
 
        this._code = '';
        this.currentIndent = '';
        this.inFunction = false;
 
        this._doneListeners = [];
 
 
        this.builder = context.builder;
 
        this.context = context;
 
        ok(this.builder, '"this.builder" is required');
 
        this._codegenCodeMethodName = 'generate' +
            context.outputType.toUpperCase() +
            'Code';
    }
 
    addVar(name, value) {
        return this.context.addVar(name, value);
    }
 
    addStaticVar(name, value) {
        return this.context.addStaticVar(name, value);
    }
 
    addStaticCode(code) {
        this.context.addStaticCode(code);
    }
 
    addDependency(path, type, options) {
        this.context.addDependency(path, type, options);
    }
 
    pushMeta(key, value, unique) {
        this.context.pushMeta(key, value, unique);
    }
 
    setMeta(key, value) {
        this.context.setMeta(key, value);
    }
 
    getEscapeXmlAttrVar() {
        return this.context.getEscapeXmlAttrVar();
    }
 
    importModule(varName, path) {
        return this.context.importModule(varName, path);
    }
 
    _invokeCodeGenerator(func, node, isMethod) {
        try {
            if (isMethod) {
                return func.call(node, this);
            } else {
                return func.call(node, node, this);
            }
        } catch(err) {
            var errorMessage = 'Generating code for ';
 
            if (node instanceof HtmlElement) {
                errorMessage += '<'+node.tagName+'> tag';
            } else {
                errorMessage += node.type + ' node';
            }
 
            if (node.pos) {
                errorMessage += ' ('+this.context.getPosInfo(node.pos)+')';
            }
 
            errorMessage += ' failed. Error: ' + err;
 
            throw createError(errorMessage, err /* cause */);
        }
    }
 
    _generateCode(node, finalNodes) {
        if (isArray(node)) {
            node.forEach((child) => {
                this._generateCode(child, finalNodes);
            });
            return;
        } else if (node instanceof Container) {
            node.forEach((child) => {
                if (child.container === node) {
                    this._generateCode(child, finalNodes);
                }
            });
            return;
        }
 
        if (node == null) {
            return;
        }
 
        if (typeof node === 'string' || node._finalNode || !(node instanceof Node)) {
            finalNodes.push(node);
            return;
        }
 
        if (node._normalizeChildTextNodes) {
            node._normalizeChildTextNodes(this.context);
        }
 
        let oldCurrentNode = this._currentNode;
        this._currentNode = node;
 
        var beforeAfterEvent = new GeneratorEvent(node, this);
 
        var isWhitespacePreserved = node.isPreserveWhitespace();
 
        if (isWhitespacePreserved) {
            this.context.beginPreserveWhitespace();
        }
 
        beforeAfterEvent.isBefore = true;
        beforeAfterEvent.node.emit('beforeGenerateCode', beforeAfterEvent);
        this.context.emit('beforeGenerateCode:' + beforeAfterEvent.node.type, beforeAfterEvent);
        this.context.emit('beforeGenerateCode', beforeAfterEvent);
 
        if (beforeAfterEvent.insertedNodes) {
            this._generateCode(beforeAfterEvent.insertedNodes, finalNodes);
            beforeAfterEvent.insertedNodes = null;
        }
 
        let codeGeneratorFunc;
        let generatedCode;
 
        if (node.getCodeGenerator) {
            codeGeneratorFunc = node.getCodeGenerator(this.outputType);
 
            if (codeGeneratorFunc) {
                node.setCodeGenerator(null);
 
                generatedCode = this._invokeCodeGenerator(codeGeneratorFunc, node, false);
 
                if (generatedCode === null) {
                    node = null;
                } else if (generatedCode !== undefined && generatedCode !== node) {
                    node = null;
                    this._generateCode(generatedCode, finalNodes);
                }
            }
        }
 
        if (node != null) {
            codeGeneratorFunc = node.generateCode;
 
            if (!codeGeneratorFunc) {
                codeGeneratorFunc = node[this._codegenCodeMethodName];
            }
 
            if (codeGeneratorFunc) {
                generatedCode = this._invokeCodeGenerator(codeGeneratorFunc, node, true);
 
                if (generatedCode === undefined || generatedCode === node) {
                    finalNodes.push(node);
                } else if (generatedCode === null) {
                    // If nothing was returned then don't generate any code
                } else {
                    this._generateCode(generatedCode, finalNodes);
                }
            } else {
                finalNodes.push(node);
            }
        }
 
        beforeAfterEvent.isBefore = false;
        beforeAfterEvent.node.emit('afterGenerateCode', beforeAfterEvent);
        this.context.emit('afterGenerateCode:' + beforeAfterEvent.node.type, beforeAfterEvent);
        this.context.emit('afterGenerateCode', beforeAfterEvent);
 
        if (beforeAfterEvent.insertedNodes) {
            this._generateCode(beforeAfterEvent.insertedNodes, finalNodes);
            beforeAfterEvent.insertedNodes = null;
        }
 
        if (isWhitespacePreserved) {
            this.context.endPreserveWhitespace();
        }
 
        this._currentNode = oldCurrentNode;
    }
 
    generateCode(node) {
        if (!node) {
            return null;
        }
 
        if (node._finalNode) {
            return node;
        }
 
        let finalNodes = new FinalNodes();
 
        var isList = typeof node.forEach === 'function';
 
        this._generateCode(node, finalNodes);
 
        finalNodes = finalNodes.nodes;
 
        if (!isList) {
            if (finalNodes.length === 0) {
                return null;
            } else if (finalNodes.length === 1) {
                return finalNodes[0];
            }
        }
 
        return finalNodes;
    }
 
    isLiteralNode(node) {
        return node instanceof Literal;
    }
 
    isIdentifierNode(node) {
        return node instanceof Identifier;
    }
 
    isPreserveWhitespaceEnabled() {
        return false;
    }
 
    addError(message, code) {
        ok('"message" is required');
 
        let node = this._currentNode;
 
        if (typeof message === 'object') {
            let errorInfo = message;
            errorInfo.node = node;
            this.context.addError(errorInfo);
        } else {
            this.context.addError({node, message, code});
        }
    }
 
    onDone(listenerFunc) {
        this._doneListeners.push(listenerFunc);
    }
 
    getRequirePath(targetFilename) {
        return this.context.getRequirePath(targetFilename);
    }
 
    resolvePath(pathExpression) {
        return this.context.resolvePath(pathExpression);
    }
}
 
module.exports = CodeGenerator;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
 
 
1
1
1
1
1
1
1
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
'use strict';
 
const isArray = Array.isArray;
const Node = require('./ast/Node');
const Literal = require('./ast/Literal');
const Identifier = require('./ast/Identifier');
const ok = require('assert').ok;
const Container = require('./ast/Container');
const Comment = require('./ast/Comment');
const isValidJavaScriptVarName = require('./util/isValidJavaScriptVarName');
 
class CodeWriter {
    constructor(options, builder) {
        ok(builder, '"builder" is required');
        options = options || {};
        this.builder = builder;
        this.root = null;
        this._indentStr = options.indent != null ? options.indent : '  ';
        this._indentSize = this._indentStr.length;
 
        this._code = '';
        this.currentIndent = '';
    }
 
    getCode() {
        return this._code;
    }
 
    writeBlock(body) {
        if (!body) {
            this.write('{}');
            return;
        }
 
        if (typeof body === 'function') {
            body = body();
        }
 
        if (!body ||
            (Array.isArray(body) && body.length === 0) ||
            (body instanceof Container && body.length === 0)) {
            this.write('{}');
            return;
        }
 
        this.write('{\n')
            .incIndent();
 
        this.writeStatements(body);
 
        this.decIndent()
            .writeLineIndent()
            .write('}');
    }
 
    writeStatements(nodes) {
        if (!nodes) {
            return;
        }
 
        ok(nodes, '"nodes" expected');
        let firstStatement = true;
 
        var writeNode = (node) => {
            if (Array.isArray(node) || (node instanceof Container)) {
                node.forEach(writeNode);
                return;
            } else {
                if (firstStatement) {
                    firstStatement = false;
                } else {
                    this._write('\n');
                }
 
                this.writeLineIndent();
 
                if (typeof node === 'string') {
                    this._write(node);
                } else {
                    node.statement = true;
                    this.write(node);
                }
 
                if (this._code.endsWith('\n')) {
                    // Do nothing
                } else if (this._code.endsWith(';')) {
                    this._code += '\n';
                }  else if (this._code.endsWith('\n' + this.currentIndent) || node instanceof Comment) {
                    // Do nothing
                } else {
                    this._code += ';\n';
                }
            }
        };
 
        if (nodes instanceof Node) {
            writeNode(nodes);
        } else {
            nodes.forEach(writeNode);
        }
    }
 
    write(code) {
        if (code == null || code === '') {
            return;
        }
 
        if (code instanceof Node) {
            let node = code;
            if (!node.writeCode) {
                throw new Error('Node does not have a `writeCode` method: ' + JSON.stringify(node, null, 4));
            }
            node.writeCode(this);
        } else if (isArray(code) || code instanceof Container) {
            code.forEach(this.write, this);
            return;
        } else if (typeof code === 'string') {
            this._code += code;
        }  else if (typeof code === 'boolean' || typeof code === 'number') {
            this._code += code.toString();
        } else {
            throw new Error('Illegal argument: ' + JSON.stringify(code));
        }
 
        return this;
    }
 
    _write(code) {
        this._code += code;
        return this;
    }
 
    incIndent(count) {
        if (count != null) {
            for (let i=0; i<count; i++) {
                this.currentIndent += ' ';
            }
        } else {
            this.currentIndent += this._indentStr;
        }
 
        return this;
    }
 
    decIndent(count) {
        if (count == null) {
            count = this._indentSize;
        }
 
        this.currentIndent = this.currentIndent.substring(
            0,
            this.currentIndent.length - count);
 
        return this;
    }
 
    writeLineIndent() {
        this._code += this.currentIndent;
        return this;
    }
 
    writeIndent() {
        this._code += this._indentStr;
        return this;
    }
 
    isLiteralNode(node) {
        return node instanceof Literal;
    }
 
    isIdentifierNode(node) {
        return node instanceof Identifier;
    }
 
    writeLiteral(value) {
        if (value === null) {
            this.write('null');
        } else if (value === undefined) {
            this.write('undefined');
        } else if (typeof value === 'string') {
            this.write(JSON.stringify(value));
        } else if (value === true) {
            this.write('true');
        } else if (value === false) {
            this.write('false');
        }  else if (isArray(value)) {
            if (value.length === 0) {
                this.write('[]');
                return;
            }
 
            this.write('[\n');
            this.incIndent();
 
            for (let i=0; i<value.length; i++) {
                let v = value[i];
 
                this.writeLineIndent();
 
                if (v instanceof Node) {
                    this.write(v);
                } else {
                    this.writeLiteral(v);
                }
 
                if (i < value.length - 1) {
                    this.write(',\n');
                } else {
                    this.write('\n');
                }
            }
 
            this.decIndent();
            this.writeLineIndent();
            this.write(']');
        } else if (typeof value === 'number') {
            this.write(value.toString());
        } else if (value instanceof RegExp) {
            this.write(value.toString());
        } else if (typeof value === 'object') {
            let keys = Object.keys(value);
            if (keys.length === 0) {
                this.write('{}');
                return;
            }
 
            this.incIndent();
            this.write('{\n');
            this.incIndent();
 
            for (let i=0; i<keys.length; i++) {
                let k = keys[i];
                let v = value[k];
 
                this.writeLineIndent();
 
                if (isValidJavaScriptVarName(k)) {
                    this.write(k + ': ');
                } else {
                    this.write(JSON.stringify(k) + ': ');
                }
 
                if (v instanceof Node) {
                    this.write(v);
                } else {
                    this.writeLiteral(v);
                }
 
                if (i < keys.length - 1) {
                    this.write(',\n');
                } else {
                    this.write('\n');
                }
            }
 
            this.decIndent();
            this.writeLineIndent();
            this.write('}');
            this.decIndent();
        }
    }
}
 
module.exports = CodeWriter;
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
 
 
1
1
1
1
1
 
1
1
1
1
1
1
1
1
1
1
1
1
 
1
 
1
 
 
 
1
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
1
 
 
'use strict';
 
var ok = require('assert').ok;
var path = require('path');
var complain = require('complain');
var taglibLookup = require('./taglib-lookup');
var charProps = require('char-props');
 
var UniqueVars = require('./util/UniqueVars');
var PosInfo = require('./util/PosInfo');
var CompileError = require('./CompileError');
var path = require('path');
var Node = require('./ast/Node');
var macros = require('./util/macros');
var extend = require('raptor-util/extend');
var Walker = require('./Walker');
var EventEmitter = require('events').EventEmitter;
var utilFingerprint = require('./util/finger-print');
var htmlElements = require('./util/html-elements');
var markoModules = require('./modules');
 
const markoPkgVersion = require('../package.json').version;
 
const FLAG_PRESERVE_WHITESPACE = 'PRESERVE_WHITESPACE';
 
 
 
function getTaglibPath(taglibPath) {
    if (typeof window === 'undefined') {
        return path.relative(process.cwd(), taglibPath);
    } else {
        return taglibPath;
    }
}
 
function removeExt(filename) {
    var ext = path.extname(filename);
    if (ext) {
        return filename.slice(0, 0 - ext.length);
    } else {
        return filename;
    }
}
 
function requireResolve(builder, path) {
    var requireResolveNode = builder.memberExpression(
        builder.identifier('require'),
        builder.identifier('resolve'));
 
 
    return builder.functionCall(requireResolveNode, [ path ]);
}
 
const helpers = {
    'attr': 'a',
    'attrs': 'as',
    'classAttr': 'ca',
    'classList': 'cl',
    'const': 'const',
    'createElement': 'e',
    'createInlineTemplate': {
        vdom: { module: 'marko/runtime/vdom/helper-createInlineTemplate'},
        html: { module: 'marko/runtime/html/helper-createInlineTemplate'}
    },
    'escapeXml': 'x',
    'escapeXmlAttr': 'xa',
    'escapeScript': 'xs',
    'escapeStyle': 'xc',
    'forEach': 'f',
    'forEachProp': { module: 'marko/runtime/helper-forEachProperty' },
    'forEachPropStatusVar': { module: 'marko/runtime/helper-forEachPropStatusVar' },
    'forEachWithStatusVar': { module: 'marko/runtime/helper-forEachWithStatusVar' },
    'forRange': { module: 'marko/runtime/helper-forRange' },
    'include': 'i',
    'loadNestedTag': { module: 'marko/runtime/helper-loadNestedTag' },
    'loadTag': 't',
    'loadTemplate': { module: 'marko/runtime/helper-loadTemplate' },
    'mergeNestedTagsHelper': { module: 'marko/runtime/helper-mergeNestedTags' },
    'merge': { module: 'marko/runtime/helper-merge' },
    'renderComponent': { module: 'marko/components/taglib/helpers/renderComponent' },
    'str': 's',
    'styleAttr': {
        vdom: { module: 'marko/runtime/vdom/helper-styleAttr'},
        html: 'sa'
    },
    'createText': 't'
};
 
class CompileContext extends EventEmitter {
    constructor(src, filename, builder, options) {
        super();
        ok(typeof src === 'string', '"src" string is required');
        ok(filename, '"filename" is required');
 
        this.src = src;
        this.filename = filename;
        this.builder = builder;
 
        this.dirname = path.dirname(filename);
        this.taglibLookup = taglibLookup.buildLookup(this.dirname);
        this.data = {};
        this._dataStacks = {};
        this.meta = {};
 
        this.options = options || {};
 
        const writeVersionComment = this.options.writeVersionComment;
 
        this.outputType = this.options.output || 'html';
        this.compilerType = this.options.compilerType || 'marko';
        this.compilerVersion = this.options.compilerVersion || markoPkgVersion;
        this.writeVersionComment = writeVersionComment !== 'undefined' ? writeVersionComment : true;
 
        this._vars = {};
        this._uniqueVars = new UniqueVars();
        this._staticVars = {};
        this._staticCode = null;
        this._uniqueStaticVars = new UniqueVars();
        this._srcCharProps = null;
        this._flags = {};
        this._errors = [];
        this._macros = null;
        this._preserveWhitespace = null;
        this._preserveComments = null;
        this.inline = this.options.inline === true;
        this.useMeta = this.options.meta !== false;
        this._moduleRuntimeTarget = this.outputType === 'vdom' ? 'marko/vdom' : 'marko/html';
        this.unrecognizedTags = [];
        this._parsingFinished = false;
 
        this._helpersIdentifier = null;
 
        if (this.options.preserveWhitespace) {
            this.setPreserveWhitespace(true);
        }
 
        this._helpers = {};
        this._imports = {};
        this._fingerprint = undefined;
        this._optimizers = undefined;
    }
 
    setInline(isInline) {
        this.inline = isInline === true;
    }
 
    getPosInfo(pos) {
        var srcCharProps = this._srcCharProps || (this._srcCharProps = charProps(this.src));
        let line = srcCharProps.lineAt(pos)+1;
        let column = srcCharProps.columnAt(pos);
        return new PosInfo(this.filename, line, column);
    }
 
    getNodePos(node) {
        if (node.pos) {
            return this.getPosInfo(node.pos);
        } else {
            return new PosInfo(this.filename);
        }
    }
 
    setFlag(name) {
        this.pushFlag(name);
    }
 
    clearFlag(name) {
        delete this._flags[name];
    }
 
    isFlagSet(name) {
        return this._flags.hasOwnProperty(name);
    }
 
    pushFlag(name) {
        if (this._flags.hasOwnProperty(name)) {
            this._flags[name]++;
        } else {
            this._flags[name] = 1;
        }
    }
 
    popFlag(name) {
        if (!this._flags.hasOwnProperty(name)) {
            throw new Error('popFlag() called for "' + name + '" when flag was not set');
        }
 
        if (--this._flags[name] === 0) {
            delete this._flags[name];
        }
    }
 
    pushData(key, data) {
        var dataStack = this._dataStacks[key];
        if (!dataStack) {
            dataStack = this._dataStacks[key] = [];
        }
 
        dataStack.push(data);
 
        return {
            pop: () => {
                this.popData(key);
            }
        };
    }
 
    popData(key) {
        var dataStack = this._dataStacks[key];
 
        if (!dataStack || dataStack.length === 0) {
            throw new Error('No data pushed for "' + key + '"');
        }
 
        dataStack.pop();
 
        if (dataStack.length === 0) {
            delete this.data[key];
        }
    }
 
    getData(name) {
        var dataStack = this._dataStacks[name];
        if (dataStack) {
            return dataStack[dataStack.length - 1];
        }
 
        return this.data[name];
    }
 
    deprecate(message, node) {
        var currentNode = node || this._currentNode;
        var location = currentNode && currentNode.pos;
 
        if (location != null) {
            location = this.getPosInfo(location).toString();
        }
 
        complain(message, { location });
    }
 
    addError(errorInfo) {
        if (errorInfo instanceof Node) {
            let node = arguments[0];
            let message = arguments[1];
            let code = arguments[2];
            let pos = arguments[3];
            errorInfo = {
                node,
                message,
                code,
                pos
            };
        } else if (typeof errorInfo === 'string') {
            let message = arguments[0];
            let code = arguments[1];
            let pos = arguments[2];
 
            errorInfo = {
                message,
                code,
                pos
            };
        }
 
        if(errorInfo && !errorInfo.node) {
            errorInfo.node = this._currentNode;
        }
 
        this._errors.push(new CompileError(errorInfo, this));
    }
 
    hasErrors() {
        return this._errors.length !== 0;
    }
 
    getErrors() {
        return this._errors;
    }
 
    getRequirePath(targetFilename) {
        return markoModules.deresolve(targetFilename, this.dirname);
    }
 
    importModule(varName, path) {
        if (typeof path !== 'string') {
            throw new Error('"path" should be a string');
        }
 
        var varId = this._imports[path];
 
        if (!varId) {
            var builder = this.builder;
            var requireFuncCall = this.builder.require(builder.literal(path));
            this._imports[path] = varId = this.addStaticVar(varName, requireFuncCall);
        }
 
        return varId;
    }
 
    addVar(name, init) {
        var actualVarName = this._uniqueVars.addVar(name, init);
        this._vars[actualVarName] = init;
        return this.builder.identifier(actualVarName);
    }
 
    getVars() {
        return this._vars;
    }
 
    addStaticVar(name, init) {
        var actualVarName = this._uniqueStaticVars.addVar(name, init);
        this._staticVars[actualVarName] = init;
        return this.builder.identifier(actualVarName);
    }
 
    getStaticVars() {
        return this._staticVars;
    }
 
    addStaticCode(code) {
        if (!code) {
            return;
        }
 
        if (typeof code === 'string') {
            // Wrap the String code in a Code AST node so that
            // the code will be indented properly
            code = this.builder.code(code);
        }
 
        if (this._staticCode == null) {
            this._staticCode = [code];
        } else {
            this._staticCode.push(code);
        }
    }
 
    getStaticCode() {
        return this._staticCode;
    }
 
    getTagDef(tagName) {
        var taglibLookup = this.taglibLookup;
 
        if (typeof tagName === 'string') {
            return taglibLookup.getTag(tagName);
        } else {
            let elNode = tagName;
            if (elNode.tagDef) {
                return elNode.tagDef;
            }
 
            return taglibLookup.getTag(elNode.tagName);
        }
    }
 
    addErrorUnrecognizedTag(tagName, elNode) {
        this.addError({
            node: elNode,
            message: 'Unrecognized tag: ' + tagName + ' - More details: https://github.com/marko-js/marko/wiki/Error:-Unrecognized-Tag'
        });
    }
 
    createNodeForEl(tagName, attributes, argument, openTagOnly, selfClosed) {
        var elDef;
        var builder = this.builder;
 
        if (typeof tagName === 'object') {
            elDef = tagName;
            tagName = elDef.tagName;
            attributes = elDef.attributes;
        } else {
            elDef = { tagName, argument, attributes, openTagOnly, selfClosed };
        }
 
        if (elDef.tagName === '') {
            elDef.tagName = tagName = 'assign';
        }
 
        if (!attributes) {
            attributes = elDef.attributes = [];
        } else if (typeof attributes === 'object') {
            if (!Array.isArray(attributes)) {
                attributes = elDef.attributes = Object.keys(attributes).map((attrName) => {
                    var attrDef = {
                        name: attrName
                    };
 
                    var val = attributes[attrName];
                    if (val == null) {
 
                    } if (val instanceof Node) {
                        attrDef.value = val;
                    } else {
                        extend(attrDef, val);
                    }
 
                    return attrDef;
                });
            }
        } else {
            throw new Error('Invalid attributes');
        }
 
        var node;
        var elNode = builder.htmlElement(elDef);
        elNode.pos = elDef.pos;
 
        this._currentNode = elNode;
 
        var tagDef;
 
        var taglibLookup = this.taglibLookup;
 
        if (typeof tagName === 'string' && tagName.startsWith('@')) {
            // NOTE: The tag definition can't be determined now since it will be
            //       determined by the parent custom tag.
            node = builder.customTag(elNode);
            node.body = node.makeContainer(node.body.items);
        } else {
            if (typeof tagName === 'string') {
                tagDef = taglibLookup.getTag(tagName);
                if (!tagDef &&
                        !this.isMacro(tagName) &&
                        tagName.indexOf(':') === -1 &&
                        !htmlElements.isRegisteredElement(tagName, this.dirname)) {
 
                    if (this._parsingFinished) {
                        this.addErrorUnrecognizedTag(tagName, elNode);
                    } else {
                        // We don't throw an error right away since the tag
                        // may be a macro that gets registered later
                        this.unrecognizedTags.push({
                            node: elNode,
                            tagName: tagName
                        });
                    }
 
                }
            }
 
            if (tagDef) {
                var nodeFactoryFunc = tagDef.getNodeFactory();
                if (nodeFactoryFunc) {
                    var newNode = nodeFactoryFunc(elNode, this);
                    if (!(newNode instanceof Node)) {
                        throw new Error('Invalid node returned from node factory for tag "' + tagName + '".');
                    }
 
                    if (newNode != node) {
                        // Make sure the body container is associated with the correct node
                        if (newNode.body && newNode.body !== node) {
                            newNode.body = newNode.makeContainer(newNode.body.items);
                        }
                        node = newNode;
                    }
                }
            }
 
            if (!node) {
                node = elNode;
            }
        }
 
        if (tagDef && tagDef.noOutput) {
            node.noOutput = true;
        }
 
        node.pos = elDef.pos;
 
        var foundAttrs = {};
 
        // Validate the attributes
        attributes.forEach((attr) => {
            let attrName = attr.name;
            if (!attrName) {
                // Attribute will be name for placeholder attributes. For example: <div ${data.myAttrs}>
                return;
            }
            let attrDef = taglibLookup.getAttribute(tagName, attrName);
            if (!attrDef) {
                if (tagDef) {
                    if (node.removeAttribute) {
                        node.removeAttribute(attrName);
                    }
 
                    // var isAttrForTaglib = compiler.taglibs.isTaglib(attrUri);
                    //Tag doesn't allow dynamic attributes
                    this.addError({
                        node: node,
                        message: 'The tag "' + tagName + '" in taglib "' + getTaglibPath(tagDef.taglibId) + '" does not support attribute "' + attrName + '"'
                    });
 
                }
                return;
            }
 
            if (attrDef.setFlag) {
                node.setFlag(attrDef.setFlag);
            }
 
            attr.def = attrDef;
 
            foundAttrs[attrName] = true;
        });
 
        if (tagDef) {
            // Add default values for any attributes. If an attribute has a declared
            // default value and the attribute was not found on the element
            // then add the attribute with the specified default value
            tagDef.forEachAttribute((attrDef) => {
                var attrName = attrDef.name;
 
                if (attrDef.hasOwnProperty('defaultValue') && !foundAttrs.hasOwnProperty(attrName)) {
                    attributes.push({
                        name: attrName,
                        value: builder.literal(attrDef.defaultValue)
                    });
                } else if (attrDef.required === true) {
                    // TODO Only throw an error if there is no data argument provided (just HTML attributes)
                    if (!foundAttrs.hasOwnProperty(attrName)) {
                        this.addError({
                            node: node,
                            message: 'The "' + attrName + '" attribute is required for tag "' + tagName + '" in taglib "' + getTaglibPath(tagDef.taglibId) + '".'
                        });
                    }
                }
            });
 
            node.tagDef = tagDef;
        }
 
        return node;
    }
 
    isMacro(name) {
        if (!this._macros) {
            return false;
        }
 
        return this._macros.isMacro(name);
    }
 
    getRegisteredMacro(name) {
        if (!this._macros) {
            return undefined;
        }
 
        return this._macros.getRegisteredMacro(name);
    }
 
    registerMacro(name, params) {
        if (!this._macros) {
            this._macros = macros.createMacrosContext();
        }
 
        return this._macros.registerMacro(name, params);
    }
 
    importTemplate(relativePath, varName) {
        ok(typeof relativePath === 'string', '"path" should be a string');
        var builder = this.builder;
		varName = varName || removeExt(path.basename(relativePath)) + '_template';
 
        var templateVar;
 
        if (this.options.browser || this.options.requireTemplates) {
            // When compiling a Marko template for the browser we just use `require('./template.marko')`
            templateVar = this.addStaticVar(varName, builder.require(builder.literal(relativePath)));
        } else {
            // When compiling a Marko template for the server we just use `loadTemplate(require.resolve('./template.marko'))`
            let loadTemplateArg = requireResolve(builder, builder.literal(relativePath));
            let loadFunctionCall = builder.functionCall(this.helper('loadTemplate'), [ loadTemplateArg ]);
            templateVar = this.addStaticVar(varName, loadFunctionCall);
        }
 
        this.pushMeta('tags', builder.literal(relativePath), true);
 
        return templateVar;
    }
 
    addDependency(path, type, options) {
        var dependency;
        if(typeof path === 'object') {
            dependency = path;
        } else {
            dependency = (type ? type+':' : '') + path;
        }
        this.pushMeta('deps', dependency, true);
    }
 
    pushMeta(key, value, unique) {
        var property;
 
        property = this.meta[key];
 
        if(!property) {
            this.meta[key] = [value];
        } else if(!unique || !property.some(e => JSON.stringify(e) === JSON.stringify(value))) {
            property.push(value);
        }
    }
 
    setMeta(key, value) {
        this.meta[key] = value;
    }
 
    setPreserveWhitespace(preserveWhitespace) {
        this._preserveWhitespace = preserveWhitespace;
    }
 
    beginPreserveWhitespace() {
        this.pushFlag(FLAG_PRESERVE_WHITESPACE);
    }
 
    endPreserveWhitespace() {
        this.popFlag(FLAG_PRESERVE_WHITESPACE);
    }
 
    isPreserveWhitespace() {
        if (this.isFlagSet(FLAG_PRESERVE_WHITESPACE) || this._preserveWhitespace === true) {
            return true;
        }
    }
 
    setPreserveComments(preserveComments) {
        this._preserveComments = preserveComments;
    }
 
    isPreserveComments() {
        return this._preserveComments === true;
    }
 
    createWalker(options) {
        return new Walker(options);
    }
 
    /**
     * Statically resolves a path if it is a literal string. Otherwise, it returns the input expression.
     */
    resolvePath(pathExpression) {
        ok(pathExpression, '"pathExpression" is required');
 
        if (pathExpression.type === 'Literal') {
            let path = pathExpression.value;
            if (typeof path === 'string') {
                return this.addStaticVar(path, this.builder.requireResolve(pathExpression));
            }
        }
        return pathExpression;
    }
 
    resolveTemplate(pathExpression) {
        ok(pathExpression, '"pathExpression" is required');
 
        if (pathExpression.type === 'Literal') {
            let path = pathExpression.value;
            if (typeof path === 'string') {
                return this.importTemplate(path);
            }
        }
 
        return pathExpression;
    }
 
    getStaticNodes(additionalVars) {
        let builder = this.builder;
        let staticNodes = [];
        let staticVars = this.getStaticVars();
 
        let staticVarNodes = Object.keys(staticVars).map((varName) => {
            var varInit = staticVars[varName];
            return builder.variableDeclarator(varName, varInit);
        });
 
        if(additionalVars) {
            staticVarNodes = additionalVars.concat(staticVarNodes);
        }
 
        if (staticVarNodes.length) {
            staticNodes.push(this.builder.vars(staticVarNodes));
        }
 
        var staticCodeArray = this.getStaticCode();
 
        if (staticCodeArray) {
            staticNodes = staticNodes.concat(staticCodeArray);
        }
 
        return staticNodes;
    }
 
    get helpersIdentifier() {
        if (!this._helpersIdentifier) {
            var target = this.outputType === 'vdom' ? 'marko/runtime/vdom/helpers' : 'marko/runtime/html/helpers';
            this._helpersIdentifier = this.importModule('marko_helpers', target);
        }
        return this._helpersIdentifier;
    }
 
    helper(name) {
        var helperIdentifier = this._helpers[name];
        if (!helperIdentifier) {
            var helperInfo = helpers[name];
 
            if (helperInfo && typeof helperInfo === 'object') {
                if (!helperInfo.module) {
                    helperInfo = helperInfo[this.outputType];
                }
            }
 
            if (!helperInfo) {
                throw new Error('Invalid helper: ' + name);
            }
 
            if (typeof helperInfo === 'string') {
                let methodName = helperInfo;
                var methodIdentifier = this.builder.identifier(methodName);
 
                helperIdentifier = this.addStaticVar(
                    'marko_' + name,
                    this.builder.memberExpression(this.helpersIdentifier, methodIdentifier));
            } else if (helperInfo && helperInfo.module) {
                helperIdentifier = this.addStaticVar(
                    'marko_' + name,
                    this.builder.require(this.builder.literal(helperInfo.module)));
            } else {
                throw new Error('Invalid helper: ' + name);
            }
 
            this._helpers[name] = helperIdentifier;
        }
 
        return helperIdentifier;
    }
 
    getFingerprint(len) {
        var fingerprint = this._fingerprint;
        if (!fingerprint) {
            this._fingerprint = fingerprint = utilFingerprint(this.src);
        }
 
        if (len == null || len >= this._fingerprint) {
            return fingerprint;
        } else {
            return fingerprint.substring(0, len);
        }
    }
 
    addOptimizer(optimizer) {
        if (this._optimizers) {
            this._optimizers.push(optimizer);
        } else {
            this._optimizers = [optimizer];
        }
    }
 
    optimize(rootNode) {
        if (this._optimizers) {
            this._optimizers.forEach((optimizer) => {
                optimizer.optimize(rootNode, this);
            });
        }
    }
 
    getModuleRuntimeTarget() {
        return this._moduleRuntimeTarget;
    }
}
 
CompileContext.prototype.util = {
    isValidJavaScriptIdentifier: require('./util/isValidJavaScriptIdentifier'),
    isJavaScriptReservedWord: require('./util/isJavaScriptReservedWord')
};
 
module.exports = CompileContext;
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
class CompileError {
    constructor(errorInfo, context) {
        this.context = context;
        this.node = errorInfo.node;
        this.message = errorInfo.message;
        this.code = errorInfo.code;
 
        var pos = errorInfo.pos;
        var endPos = errorInfo.endPos;
 
        if (pos == null) {
            pos = this.node && this.node.pos;
        }
 
        if (endPos == null) {
            endPos = this.node && this.node.endPos;
        }
 
        if (pos != null) {
            pos = context.getPosInfo(pos);
        }
 
        if (endPos != null) {
            endPos = context.getPosInfo(endPos);
        }
 
        this.pos = pos;
        this.endPos = endPos;
    }
 
    toString() {
        var pos = this.pos;
        if (pos) {
            pos = '[' + pos + '] ';
        } else {
            pos = '';
        }
        var str = pos + this.message;
        if (pos == null && this.node) {
            str += ' (' + this.node.toString() + ')';
        }
        return str;
    }
}
 
module.exports = CompileError;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
 
1
1
1
1
1
1
 
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
1
1
 
1
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
'use strict';
var ok = require('assert').ok;
var path = require('path');
var CodeGenerator = require('./CodeGenerator');
var CodeWriter = require('./CodeWriter');
var createError = require('raptor-util/createError');
var resolveDep = require('../runtime/dependencies').resolveDep;
 
const FLAG_TRANSFORMER_APPLIED = 'transformerApply';
 
function transformNode(node, context) {
    try {
        context.taglibLookup.forEachNodeTransformer(node, function (transformer) {
            if (node.isDetached()) {
                return;    //The node might have been removed from the tree
            }
            if (!node.isTransformerApplied(transformer)) {
                //Check to make sure a transformer of a certain type is only applied once to a node
                node.setTransformerApplied(transformer);
                //Mark the node as have been transformed by the current transformer
                context.setFlag(FLAG_TRANSFORMER_APPLIED);
                //Set the current node
                context._currentNode = node;
                //Set the flag to indicate that a node was transformed
                // node.compiler = this;
                var transformerFunc = transformer.getFunc();
                transformerFunc.call(transformer, node, context);    //Have the transformer process the node (NOTE: Just because a node is being processed by the transformer doesn't mean that it has to modify the parse tree)
            }
        });
    } catch (e) {
        throw createError(new Error('Unable to compile template at path "' + context.filename + '". Error: ' + e.message), e);
    }
}
 
function transformTreeHelper(node, context) {
    transformNode(node, context);
 
    /*
     * Now process the child nodes by looping over the child nodes
     * and transforming the subtree recursively
     *
     * NOTE: The length of the childNodes array might change as the tree is being performed.
     *       The checks to prevent transformers from being applied multiple times makes
     *       sure that this is not a problem.
     */
    node.forEachChild(function (childNode) {
        transformTreeHelper(childNode, context);
    });
}
 
function transformTree(rootNode, context) {
 
    context.taglibLookup.forEachTemplateTransformer((transformer) => {
        var transformFunc = transformer.getFunc();
        rootNode = transformFunc(rootNode, context) || rootNode;
    });
 
    /*
     * The tree is continuously transformed until we go through an entire pass where
     * there were no new nodes that needed to be transformed. This loop makes sure that
     * nodes added by transformers are also transformed.
     */
    do {
        context.clearFlag(FLAG_TRANSFORMER_APPLIED);
        //Reset the flag to indicate that no transforms were yet applied to any of the nodes for this pass
        transformTreeHelper(rootNode, context);    //Run the transforms on the tree
    } while (context.isFlagSet(FLAG_TRANSFORMER_APPLIED));
 
    return rootNode;
}
 
function handleErrors(context) {
    // If there were any errors then compilation failed.
    if (context.hasErrors()) {
        var errors = context.getErrors();
 
        var message = 'An error occurred while trying to compile template at path "' + context.filename + '". Error(s) in template:\n';
        for (var i = 0, len = errors.length; i < len; i++) {
            let error = errors[i];
            message += (i + 1) + ') ' + error.toString() + '\n';
        }
        var error = new Error(message);
        error.errors = errors;
        throw error;
    }
}
 
class CompiledTemplate {
    constructor(ast, context, codeGenerator) {
        this.ast = ast;
        this.context = context;
        this.filename = context.filename;
    }
 
    get dependencies() {
        var meta = this.context.meta;
        if (meta) {
            var root = path.dirname(this.filename);
            return (meta.deps || []).map(dep => resolveDep(dep, root));
        } else {
            return [];
        }
    }
 
    get code() {
        // STAGE 3: Generate the code using the final AST
        handleErrors(this.context);
 
        // console.log(module.id, 'FINAL AST:' + JSON.stringify(finalAST, null, 4));
        var codeWriter = new CodeWriter(this.context.options, this.context.builder);
        codeWriter.write(this.ast);
 
        handleErrors(this.context);
 
        // Return the generated code as the compiled output:
        var compiledSrc = codeWriter.getCode();
        return compiledSrc;
    }
}
 
class Compiler {
    constructor(options, userOptions, inline) {
        ok(options, '"options" is required');
 
        this.builder = options.builder;
        this.parser = options.parser;
 
        ok(this.builder, '"options.builder" is required');
        ok(this.parser, '"options.parser" is required');
    }
 
    compile(src, context) {
        ok(typeof src === 'string', '"src" argument should be a string');
 
        var codeGenerator = new CodeGenerator(context);
 
        // STAGE 1: Parse the template to produce the initial AST
        var ast = this.parser.parse(src, context);
        context._parsingFinished = true;
 
        if (context.unrecognizedTags) {
            for(let i=0; i<context.unrecognizedTags.length; i++) {
                let unrecognizedTag = context.unrecognizedTags[i];
                // See if the tag is a macro
                if (!context.isMacro(unrecognizedTag.tagName)) {
                    context.addErrorUnrecognizedTag(unrecognizedTag.tagName, unrecognizedTag.node);
                }
            }
        }
 
        handleErrors(context);
 
        context.root = ast;
        // console.log('ROOT', JSON.stringify(ast, null, 2));
 
        // STAGE 2: Transform the initial AST to produce the final AST
        var transformedAST = transformTree(ast, context);
        // console.log('transformedAST', JSON.stringify(ast, null, 2));
 
        handleErrors(context);
 
        var finalAST = codeGenerator.generateCode(transformedAST);
 
        handleErrors(context);
 
        return new CompiledTemplate(finalAST, context);
    }
}
 
module.exports = Compiler;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
1
 
 
 
2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
'use strict';
var htmljs = require('htmljs-parser');
 
class HtmlJsParser {
    constructor(options) {
        this.ignorePlaceholders = options && options.ignorePlaceholders === true;
    }
 
    parse(src, handlers, filename) {
        var listeners = {
            onText(event) {
                handlers.handleCharacters(event.value, event.parseMode);
            },
 
            onPlaceholder(event) {
                if (event.withinBody) {
                    if (!event.withinString) {
                        handlers.handleBodyTextPlaceholder(event.value, event.escape);
                    }
                } else if (event.withinOpenTag) {
                    // Don't escape placeholder for dynamic attributes. For example: <div ${data.myAttrs}></div>
                } else {
                    // placeholder within attribute
                    if (event.escape) {
                        event.value = '$escapeXml(' + event.value + ')';
                    } else {
                        event.value = '$noEscapeXml(' + event.value + ')';
                    }
                }
                // placeholder within content
 
            },
 
            onCDATA(event) {
                handlers.handleCharacters(event.value, 'static-text');
            },
 
            onOpenTagName(event, parser) {
                event.selfClosed = false; // Don't allow self-closed tags
 
                var tagParseOptions = handlers.getTagParseOptions(event);
 
                if (tagParseOptions) {
                    event.setParseOptions(tagParseOptions);
                }
            },
 
            onOpenTag(event, parser) {
                event.selfClosed = false; // Don't allow self-closed tags
                handlers.handleStartElement(event, parser);
 
                var tagParseOptions = handlers.getTagParseOptions(event);
                if (tagParseOptions) {
                    event.setParseOptions(tagParseOptions);
                }
            },
 
            onCloseTag(event) {
                var tagName = event.tagName;
                handlers.handleEndElement(tagName);
            },
 
            onDocumentType(event) {
 
                // Document type: <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd
                // NOTE: The value will be all of the text between "<!" and ">""
                handlers.handleDocumentType(event.value);
            },
 
            onDeclaration(event) {
                handlers.handleDeclaration(event.value);
            },
 
            onComment(event) {
                // Text within XML comment
                handlers.handleComment(event.value);
            },
 
            onScriptlet(event) {
                // <% (code) %> or $ {}
                handlers.handleScriptlet(event);
            },
 
            onError(event) {
                handlers.handleError(event);
            }
        };
 
        var parser = this.parser = htmljs.createParser(listeners, {
            ignorePlaceholders: this.ignorePlaceholders,
            isOpenTagOnly: function(tagName) {
                return handlers.isOpenTagOnly(tagName);
            }
        });
        parser.parse(src, filename);
    }
}
 
module.exports = HtmlJsParser;
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
 
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
let CodeWriter = require('./CodeWriter');
 
function fixIndentation(lines) {
    let length = lines.length;
    let startLine = 0;
    let endLine = length;
 
    for (; startLine<length; startLine++) {
        let line = lines[startLine];
        if (line.trim() !== '') {
            break;
        }
    }
 
    for (; endLine>startLine; endLine--) {
        let line = lines[endLine-1];
        if (line.trim() !== '') {
            break;
        }
    }
 
    if (endLine === startLine) {
        return '';
    }
 
    if (startLine !== 0 || endLine !== length) {
        lines = lines.slice(startLine, endLine);
    }
 
    let firstLine = lines[0];
    let indentToRemove = /^\s*/.exec(firstLine)[0];
 
    if (indentToRemove) {
        for (let i=0; i<lines.length; i++) {
            let line = lines[i];
            if (line.startsWith(indentToRemove)) {
                lines[i] = line.substring(indentToRemove.length);
            }
        }
    }
 
    return lines.join('\n');
}
 
function normalizeTemplateSrc(src) {
    let lines = src.split(/\r\n|\n\r|\n/);
    if (lines.length) {
        if (lines[0].trim() === '') {
            return fixIndentation(lines);
        }
    }
 
    return src.trim();
}
class InlineCompiler {
    constructor(context, compiler) {
        this.context = context;
        this.compiler = compiler;
        this.builder = context.builder;
 
        context.setInline(true);
    }
 
    compile(src) {
        src = normalizeTemplateSrc(src);
        // console.log('TEMPLATE SRC:>\n' + src + '\n<');
        return this.compiler.compile(src, this.context);
    }
 
    get staticCode() {
        let staticNodes = this.context.getStaticNodes();
 
        if (!staticNodes || staticNodes.length === 0) {
            return null;
        }
 
        let codeWriter = new CodeWriter(this.context.options, this.builder);
        codeWriter.write(staticNodes);
        return codeWriter.getCode();
    }
}
 
module.exports = InlineCompiler;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
 
1
1
1
 
1
 
 
 
 
 
 
 
 
1
 
1
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2
 
2
 
2
2
 
2
 
 
 
 
2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
'use strict';
var ok = require('assert').ok;
var replacePlaceholderEscapeFuncs = require('./util/replacePlaceholderEscapeFuncs');
var extend = require('raptor-util/extend');
 
var COMPILER_ATTRIBUTE_HANDLERS = {
    'preserve-whitespace': function(attr, context) {
        context.setPreserveWhitespace(true);
    },
    'preserve-comments': function(attr, context) {
        context.setPreserveComments(true);
    }
};
 
var ieConditionalCommentRegExp = /^\[if [^]*?<!\[endif\]$/;
 
function isIEConditionalComment(comment) {
    return ieConditionalCommentRegExp.test(comment);
}
 
function mergeShorthandClassNames(el, shorthandClassNames, context) {
    var builder = context.builder;
    let classNames = shorthandClassNames.map((className) => {
        return builder.parseExpression(className.value);
    });
 
    var classAttr = el.getAttributeValue('class');
    if (classAttr) {
        classNames.push(classAttr);
    }
 
    let prevClassName;
 
    var finalClassNames = [];
 
    for (var i=0; i<classNames.length; i++) {
        let className = classNames[i];
        if (prevClassName && className.type === 'Literal' && prevClassName.type === 'Literal') {
            prevClassName.value += ' ' + className.value;
        } else {
            finalClassNames.push(className);
            prevClassName = className;
        }
    }
 
    if (finalClassNames.length === 1) {
        el.setAttributeValue('class', finalClassNames[0]);
    } else {
 
        el.setAttributeValue(
            'class',
            builder.functionCall(
                context.helper('classList'),
                [
                    builder.literal(finalClassNames)
                ]));
    }
}
 
function getParserStateForTag(parser, el, tagDef) {
    var attributes = el.attributes;
    if (attributes) {
        for (var i=0; i<attributes.length; i++) {
            var attr = attributes[i];
            var attrName = attr.name;
            if (attrName === 'marko-body') {
                var parseMode;
 
                if (attr.literalValue) {
                    parseMode = attr.literalValue;
                }
 
                if (parseMode === 'static-text' ||
                    parseMode === 'parsed-text' ||
                    parseMode === 'html') {
                    return parseMode;
                } else {
                    parser.context.addError({
                        message: 'Value for "marko-body" should be one of the following: "static-text", "parsed-text", "html"',
                        code: 'ERR_INVALID_ATTR'
                    });
                    return;
                }
            } else if (attrName === 'template-helpers') {
                return 'static-text';
            } else if (attrName === 'marko-init') {
                return 'static-text';
            }
        }
    }
 
    if (tagDef) {
        var body = tagDef.body;
        if (body) {
            return body; // 'parsed-text' | 'static-text' | 'html'
        }
    }
 
    return null; // Default parse state
}
 
class Parser {
    constructor(parserImpl, options) {
        ok(parserImpl, '"parserImpl" is required');
 
        this.parserImpl = parserImpl;
 
        this.prevTextNode = null;
        this.stack = null;
 
        this.raw = options && options.raw === true;
 
        // The context gets provided when parse is called
        // but we store it as part of the object so that the handler
        // methods have access
        this.context = null;
    }
 
    _reset() {
        this.prevTextNode = null;
        this.stack = [];
    }
 
    parse(src, context) {
        ok(typeof src === 'string', '"src" should be a string');
        ok(context, '"context" is required');
 
        this._reset();
 
        this.context = context;
 
        var builder = context.builder;
        var rootNode = builder.templateRoot();
 
        this.stack.push({
            node: rootNode
        });
 
        this.parserImpl.parse(src, this, context.filename);
 
        return rootNode;
    }
 
    handleCharacters(text, parseMode) {
        var builder = this.context.builder;
 
        var escape = parseMode !== 'html';
        // NOTE: If parseMode is 'static-text' or 'parsed-text' then that means that special
        //       HTML characters may not have been escaped on the way in so we need to escape
        //       them on the way out
 
        if (this.prevTextNode && this.prevTextNode.isLiteral() && this.prevTextNode.escape === escape) {
            this.prevTextNode.argument.value += text;
        } else {
            this.prevTextNode = builder.text(builder.literal(text), escape);
            this.parentNode.appendChild(this.prevTextNode);
        }
    }
 
    handleStartElement(el, parser) {
        var context = this.context;
        var builder = context.builder;
 
        var tagName = el.tagName;
        var tagNameExpression = el.tagNameExpression;
        var attributes = el.attributes;
        var argument = el.argument; // e.g. For <for(color in colors)>, argument will be "color in colors"
 
        if (argument) {
            argument = argument.value;
        }
 
        var raw = this.raw;
 
        if (!raw) {
            if (tagNameExpression) {
                tagName = builder.parseExpression(tagNameExpression);
            } else if (tagName === 'marko-compiler-options') {
                this.parentNode.setTrimStartEnd(true);
 
                attributes.forEach(function (attr) {
                    let attrName = attr.name;
                    let handler = COMPILER_ATTRIBUTE_HANDLERS[attrName];
 
                    if (!handler) {
                        context.addError({
                            code: 'ERR_INVALID_COMPILER_OPTION',
                            message: 'Invalid Marko compiler option of "' + attrName + '". Allowed: ' + Object.keys(COMPILER_ATTRIBUTE_HANDLERS).join(', '),
                            pos: el.pos,
                            node: el
                        });
                        return;
                    }
 
                    handler(attr, context);
                });
 
                return;
            }
        }
 
        this.prevTextNode = null;
 
        var tagDef = el.tagName ? this.context.getTagDef(el.tagName) : null;
 
        var attributeParseErrors = [];
        // <div class="foo"> -> "div class=foo"
        var tagString = parser.substring(el.pos, el.endPos)
                              .replace(/^<|\/>$|>$/g, "").trim();
 
        var shouldParsedAttributes = !tagDef || tagDef.parseAttributes !== false;
 
        var parsedAttributes = [];
 
        if (shouldParsedAttributes) {
            attributes.forEach((attr) => {
                var attrValue;
                if (attr.hasOwnProperty('literalValue')) {
                    attrValue = builder.literal(attr.literalValue);
                } else if (attr.value == null) {
                    attrValue = undefined;
                } else {
                    let parsedExpression;
                    let valid = true;
                    try {
                        parsedExpression = builder.parseExpression(attr.value);
                    } catch(e) {
                        if (shouldParsedAttributes) {
                            valid = false;
                            attributeParseErrors.push('Invalid JavaScript expression for attribute "' + attr.name + '": ' + e);
                        } else {
                            // Attribute failed to parse. Skip it...
                            return;
                        }
 
                    }
 
                    if (valid) {
                        if (raw) {
                            attrValue = parsedExpression;
                        } else {
                            attrValue = replacePlaceholderEscapeFuncs(parsedExpression, context);
                        }
                    } else {
                        attrValue = null;
                    }
                }
 
                var attrDef = {
                    name: attr.name,
                    value: attrValue,
                    rawValue: attr.value
                };
 
                if (attr.argument) {
                    // TODO Do something with the argument pos
                    attrDef.argument = attr.argument.value;
                }
 
                parsedAttributes.push(attrDef);
            });
        }
 
        var elDef = {
            tagName: tagName,
            argument: argument,
            tagString,
            openTagOnly: el.openTagOnly === true,
            selfClosed: el.selfClosed === true,
            pos: el.pos,
            attributes: parsedAttributes
        };
 
        var node;
 
        if (raw) {
            node = builder.htmlElement(elDef);
            node.pos = elDef.pos;
            node.tagDef = tagDef;
        } else {
            node = this.context.createNodeForEl(elDef);
        }
 
        if (attributeParseErrors.length) {
 
            attributeParseErrors.forEach((e) => {
                context.addError(node, e);
            });
        }
 
        if (raw) {
            if (el.shorthandId) {
                let parsed = builder.parseExpression(el.shorthandId.value);
                node.rawShorthandId = parsed.value;
            }
 
            if (el.shorthandClassNames) {
                node.rawShorthandClassNames = el.shorthandClassNames.map((className) => {
                    let parsed = builder.parseExpression(className.value);
                    return parsed.value;
                });
            }
        } else {
            if (el.shorthandClassNames) {
                mergeShorthandClassNames(node, el.shorthandClassNames, context);
            }
 
            if (el.shorthandId) {
                if (node.hasAttribute('id')) {
                    context.addError(node, 'A shorthand ID cannot be used in conjunction with the "id" attribute');
                } else {
                    node.setAttributeValue('id', builder.parseExpression(el.shorthandId.value));
                }
            }
        }
 
        this.parentNode.appendChild(node);
 
        this.stack.push({
            node: node,
            tag: null
        });
    }
 
    handleEndElement(elementName) {
        if (this.raw !== true) {
            if (elementName === 'marko-compiler-options') {
                return;
            }
        }
 
        this.prevTextNode = null;
        this.stack.pop();
    }
 
    handleComment(comment) {
        this.prevTextNode = null;
 
        var builder = this.context.builder;
 
        var preserveComment = this.context.isPreserveComments() ||
            isIEConditionalComment(comment);
 
        if (this.raw || preserveComment) {
            var commentNode = builder.htmlComment(builder.literal(comment));
            this.parentNode.appendChild(commentNode);
        }
    }
 
    handleDeclaration(value) {
        this.prevTextNode = null;
 
        var builder = this.context.builder;
 
        var declarationNode = builder.declaration(builder.literal(value));
        this.parentNode.appendChild(declarationNode);
    }
 
    handleDocumentType(value) {
        this.prevTextNode = null;
 
        var builder = this.context.builder;
 
        var docTypeNode = builder.documentType(builder.literal(value));
        this.parentNode.appendChild(docTypeNode);
    }
 
    handleBodyTextPlaceholder(expression, escape) {
        this.prevTextNode = null;
        var builder = this.context.builder;
        var parsedExpression = builder.parseExpression(expression);
        var preserveWhitespace = true;
 
        var text = builder.text(parsedExpression, escape, preserveWhitespace);
        this.parentNode.appendChild(text);
    }
 
    handleScriptlet(event) {
        this.prevTextNode = null;
        var builder = this.context.builder;
        var scriptlet = builder.scriptlet(event);
        this.parentNode.appendChild(scriptlet);
    }
 
    handleError(event) {
        this.context.addError({
            message: event.message,
            code: event.code,
            pos: event.pos,
            endPos: event.endPos
        });
    }
 
    get parentNode() {
        var last = this.stack[this.stack.length-1];
        return last.node;
    }
 
    getTagParseOptions(el) {
        var tagName = el.tagName;
        var tagDef = this.context.getTagDef(tagName);
 
        var state = getParserStateForTag(this, el, tagDef);
        var parseOptions = tagDef && tagDef.parseOptions;
 
        if (!state && !parseOptions) {
            return;
        }
 
        if (parseOptions) {
            if (state) {
                // We need to merge in the state to the returned parse options
                parseOptions = extend({ state: state }, parseOptions);
            }
        } else {
            parseOptions = { state: state };
        }
 
        return parseOptions;
    }
 
    isOpenTagOnly(tagName) {
        var tagDef = this.context.getTagDef(tagName);
        return tagDef && tagDef.openTagOnly;
    }
}
 
module.exports = Parser;